@syncended/dsh-automations 0.5.1 → 0.7.0

package/lib/client.js

@@ -17,6 +17,7 @@ window.__ModuleLoader__.load({
     const {
       Button,
       Menu,
+      Pill,
       RiskConfirmation,
       IconAgentPresetOutline16,
       IconBrowseOutline16,
@@ -24,6 +25,7 @@ window.__ModuleLoader__.load({
       IconChevronDownOutline14,
       IconChevronLeftOutline14,
       IconEditOutline16,
+      IconFolderClose16,
       IconGlobeOutline14,
       IconPlayOutline16,
       IconPlusOutline16,
@@ -33,7 +35,7 @@ window.__ModuleLoader__.load({
       IconTrashOutline16,
       IconWarningOutline16,
     } = require("@deepseek-ai/dsh-client-ui-primitives");
-    const inject = ["slots"];
+    const inject = ["slots", "workspaces"];
 
     const API_PREFIX = "/api/automations";
     const POLL_MS = 5000;
@@ -43,6 +45,32 @@ window.__ModuleLoader__.load({
     const MIN_TIMEOUT_MS = 1000;
     const MAX_TIMEOUT_MS = 86400000;
     const JOB_ID_PATTERN = /^[a-z0-9][a-z0-9-]{0,62}$/;
+    const SCHEDULE_MODES = [
+      { id: "minutes", label: "Minutes" },
+      { id: "hourly", label: "Hourly" },
+      { id: "daily", label: "Daily" },
+      { id: "weekdays", label: "Weekdays" },
+      { id: "weekly", label: "Weekly" },
+      { id: "custom", label: "Custom" },
+    ];
+    const MINUTE_INTERVALS = [5, 10, 15, 20, 30];
+    const HOURLY_MINUTES = Array.from({ length: 60 }, (_, index) => index);
+    const WEEKDAYS = [
+      { value: "1", label: "Monday" },
+      { value: "2", label: "Tuesday" },
+      { value: "3", label: "Wednesday" },
+      { value: "4", label: "Thursday" },
+      { value: "5", label: "Friday" },
+      { value: "6", label: "Saturday" },
+      { value: "0", label: "Sunday" },
+    ];
+    const CRON_FIELD_GUIDE = [
+      { label: "Minute", range: "0–59" },
+      { label: "Hour", range: "0–23" },
+      { label: "Day", range: "1–31" },
+      { label: "Month", range: "1–12" },
+      { label: "Weekday", range: "0–7" },
+    ];
     let formInstanceSerial = 0;
 
     const BROWSER_TIMEZONE = (() => {
@@ -132,14 +160,20 @@ window.__ModuleLoader__.load({
       { id: "high", name: "High", description: "Use a deeper reasoning level." },
       { id: "max", name: "Max", description: "Use the strongest available reasoning level." },
     ];
+    const EMPTY_WORKSPACE_SNAPSHOT = Object.freeze({
+      items: Object.freeze([]),
+      state: "idle",
+      phase: "pending",
+      error: null,
+    });
     const OVERLAP_OPTIONS = [
-      { value: "skip", label: "skip", hint: "Skip the run if a previous run is still active." },
-      { value: "queue", label: "queue", hint: "Defer the run until the previous run finishes." },
-      { value: "allow", label: "allow", hint: "Run concurrently with any active run." },
+      { value: "skip", label: "Skip the new run", hint: "Skip the run if a previous run is still active." },
+      { value: "queue", label: "Queue the next run", hint: "Defer the run until the previous run finishes." },
+      { value: "allow", label: "Allow concurrent runs", hint: "Run concurrently with any active run." },
     ];
     const MISFIRE_OPTIONS = [
-      { value: "skip", label: "skip", hint: "Drop occurrences that were missed while the scheduler was down." },
-      { value: "run-once", label: "run-once", hint: "Run once after downtime for the latest missed occurrence." },
+      { value: "skip", label: "Skip missed runs", hint: "Drop occurrences that were missed while the scheduler was down." },
+      { value: "run-once", label: "Run once after downtime", hint: "Run once after downtime for the latest missed occurrence." },
     ];
 
     function errMessage(error) {
@@ -388,6 +422,31 @@ window.__ModuleLoader__.load({
       return Math.round(ms / 1000) + "s";
     }
 
+    function overlapPolicySummary(value) {
+      if (value === "queue") return "Queue overlaps";
+      if (value === "allow") return "Allow concurrent runs";
+      return "Skip overlaps";
+    }
+
+    function inferFormErrorField(message) {
+      const text = String(message || "").toLowerCase();
+      if (text.includes("job id")) return "id";
+      if (text.includes("timeout")) return "timeout";
+      if (text.includes("overlap")) return "overlap";
+      if (text.includes("misfire")) return "misfire";
+      if (text.includes("cron")) return "cron";
+      if (text.includes("timezone") || text.includes("time zone")) return "timezone";
+      if (text.includes("workspace")) return "cwd";
+      if (text.includes("prompt")) return "prompt";
+      if (text.includes("reasoning effort")) return "effort";
+      if (text.includes("agent preset")) return "preset";
+      if (text.includes("permission")) return "permission";
+      if (text.includes("model")) return "model";
+      if (text.includes("provider")) return "provider";
+      if (text.includes("name")) return "name";
+      return null;
+    }
+
     async function apiFetch(path, options = {}) {
       const headers = Object.assign(
         { "content-type": "application/json", "x-dsh-automation-client": "1" },
@@ -493,6 +552,304 @@ window.__ModuleLoader__.load({
       };
     }
 
+    function cronFields(value) {
+      return String(value || "").trim().split(/\s+/).filter(Boolean);
+    }
+
+    function twoDigits(value) {
+      return String(value).padStart(2, "0");
+    }
+
+    function simpleSchedule(cronValue) {
+      const cron = cronFields(cronValue).join(" ");
+      let match = cron.match(/^\*\/(5|10|15|20|30) \* \* \* \*$/);
+      if (match) return { mode: "minutes", interval: Number(match[1]), minute: 0, hour: 9, weekday: "1" };
+      match = cron.match(/^(\d{1,2}) \* \* \* \*$/);
+      if (match && Number(match[1]) <= 59) {
+        return { mode: "hourly", minute: Number(match[1]), hour: 9, weekday: "1", interval: 15 };
+      }
+      match = cron.match(/^(\d{1,2}) (\d{1,2}) \* \* 1-5$/);
+      if (match && Number(match[1]) <= 59 && Number(match[2]) <= 23) {
+        return { mode: "weekdays", minute: Number(match[1]), hour: Number(match[2]), weekday: "1", interval: 15 };
+      }
+      match = cron.match(/^(\d{1,2}) (\d{1,2}) \* \* ([0-7])$/);
+      if (match && Number(match[1]) <= 59 && Number(match[2]) <= 23) {
+        return {
+          mode: "weekly",
+          minute: Number(match[1]),
+          hour: Number(match[2]),
+          weekday: match[3] === "7" ? "0" : match[3],
+          interval: 15,
+        };
+      }
+      match = cron.match(/^(\d{1,2}) (\d{1,2}) \* \* \*$/);
+      if (match && Number(match[1]) <= 59 && Number(match[2]) <= 23) {
+        return { mode: "daily", minute: Number(match[1]), hour: Number(match[2]), weekday: "1", interval: 15 };
+      }
+      return { mode: "custom", minute: 0, hour: 9, weekday: "1", interval: 15 };
+    }
+
+    function scheduleControlValues(cronValue, fallback = {}) {
+      const fields = cronFields(cronValue);
+      const minute = /^\d{1,2}$/.test(fields[0] || "") && Number(fields[0]) <= 59
+        ? Number(fields[0])
+        : Number.isInteger(fallback.minute) ? fallback.minute : 0;
+      const hour = /^\d{1,2}$/.test(fields[1] || "") && Number(fields[1]) <= 23
+        ? Number(fields[1])
+        : Number.isInteger(fallback.hour) ? fallback.hour : 9;
+      const normalizedWeekday = fields[4] === "7" ? "0" : fields[4];
+      const weekday = WEEKDAYS.some((day) => day.value === normalizedWeekday)
+        ? normalizedWeekday
+        : WEEKDAYS.some((day) => day.value === String(fallback.weekday)) ? String(fallback.weekday) : "1";
+      const intervalMatch = /^\*\/(\d+)$/.exec(fields[0] || "");
+      const parsedInterval = intervalMatch ? Number(intervalMatch[1]) : NaN;
+      const interval = MINUTE_INTERVALS.includes(parsedInterval)
+        ? parsedInterval
+        : MINUTE_INTERVALS.includes(fallback.interval) ? fallback.interval : 15;
+      return { minute, hour, weekday, interval };
+    }
+
+    function cronForSimpleSchedule(mode, values = {}) {
+      const minute = Number.isInteger(values.minute) && values.minute >= 0 && values.minute <= 59 ? values.minute : 0;
+      const hour = Number.isInteger(values.hour) && values.hour >= 0 && values.hour <= 23 ? values.hour : 9;
+      const interval = MINUTE_INTERVALS.includes(values.interval) ? values.interval : 15;
+      const weekday = WEEKDAYS.some((day) => day.value === String(values.weekday)) ? String(values.weekday) : "1";
+      if (mode === "minutes") return "*/" + interval + " * * * *";
+      if (mode === "hourly") return minute + " * * * *";
+      if (mode === "daily") return minute + " " + hour + " * * *";
+      if (mode === "weekdays") return minute + " " + hour + " * * 1-5";
+      if (mode === "weekly") return minute + " " + hour + " * * " + weekday;
+      return null;
+    }
+
+    function scheduleModeTransition(mode, cron, values, customCron) {
+      if (mode === "custom") {
+        const restored = customCron === null ? cron : customCron;
+        return { cron: restored, customCron: restored };
+      }
+      return {
+        cron: cronForSimpleSchedule(mode, values) || cron,
+        customCron,
+      };
+    }
+
+    function describeSimpleSchedule(schedule, timezone) {
+      const time = twoDigits(schedule.hour) + ":" + twoDigits(schedule.minute);
+      const zone = timezone.trim() || "the selected time zone";
+      if (schedule.mode === "minutes") return "Every " + schedule.interval + " minutes · " + zone;
+      if (schedule.mode === "hourly") return "Every hour at :" + twoDigits(schedule.minute) + " · " + zone;
+      if (schedule.mode === "daily") return "Every day at " + time + " · " + zone;
+      if (schedule.mode === "weekdays") return "Monday–Friday at " + time + " · " + zone;
+      if (schedule.mode === "weekly") {
+        const day = WEEKDAYS.find((entry) => entry.value === schedule.weekday)?.label || "Monday";
+        return "Every " + day + " at " + time + " · " + zone;
+      }
+      return cronFields(schedule.cron).length === 5
+        ? "Custom five-field schedule · " + zone
+        : "Cron needs exactly five fields · " + zone;
+    }
+
+    function FormSection({ title, description, Icon, children, className = "" }) {
+      return h(
+        "section",
+        { className: "dsh-auto-form-section" + (className ? " " + className : "") },
+        h(
+          "header",
+          { className: "dsh-auto-form-section-head" },
+          Icon ? h("span", { className: "dsh-auto-form-section-icon", "aria-hidden": "true" }, h(Icon)) : null,
+          h(
+            "span",
+            { className: "dsh-auto-form-section-copy" },
+            h("h4", { className: "dsh-auto-form-section-title" }, title),
+            description ? h("p", { className: "dsh-auto-form-section-description" }, description) : null,
+          ),
+        ),
+        children,
+      );
+    }
+
+    function CronFieldGuide({ value }) {
+      const fields = cronFields(value);
+      return h(
+        React.Fragment,
+        null,
+        h(
+          "div",
+          { className: "dsh-auto-cron-guide", "aria-label": "Cron field order" },
+          CRON_FIELD_GUIDE.map((field, index) => h(
+            "span",
+            { key: field.label, className: "dsh-auto-cron-guide-field" },
+            h("code", { className: "dsh-auto-cron-guide-value" }, fields[index] || "—"),
+            h("span", { className: "dsh-auto-cron-guide-label" }, field.label),
+            h("span", { className: "dsh-auto-cron-guide-range" }, field.range),
+          )),
+        ),
+        h("p", { className: "dsh-auto-cron-syntax" }, "* any value · , list · - range · / step"),
+      );
+    }
+
+    function ScheduleEditor({ fieldId, cron, timezone, onCronChange, onTimezoneChange }) {
+      const detected = simpleSchedule(cron);
+      const [forceCustom, setForceCustom] = useState(false);
+      const [values, setValues] = useState(() => scheduleControlValues(cron));
+      const customCronRef = useRef(detected.mode === "custom" ? cron : null);
+      const customCronPinnedRef = useRef(detected.mode === "custom");
+      const activeMode = forceCustom || detected.mode === "custom" ? "custom" : detected.mode;
+      const applySimpleValues = (mode, nextValues) => {
+        setValues(nextValues);
+        const expression = cronForSimpleSchedule(mode, nextValues);
+        if (expression !== null) onCronChange(expression);
+      };
+      const setMode = (mode) => {
+        if (mode !== "custom" && !customCronPinnedRef.current) customCronRef.current = null;
+        const transition = scheduleModeTransition(mode, cron, values, customCronRef.current);
+        customCronRef.current = transition.customCron;
+        setForceCustom(mode === "custom");
+        if (transition.cron !== cron) onCronChange(transition.cron);
+      };
+      const setTime = (raw) => {
+        const match = /^(\d{2}):(\d{2})$/.exec(raw);
+        if (!match) return;
+        applySimpleValues(activeMode, Object.assign({}, values, {
+          hour: Number(match[1]),
+          minute: Number(match[2]),
+        }));
+      };
+      const summarySchedule = Object.assign({}, values, { mode: activeMode, cron });
+      const displayedCron = cronFields(cron).join(" ") || "—";
+
+      return h(
+        React.Fragment,
+        null,
+        h(
+          "div",
+          { className: "dsh-auto-schedule-modes dsh-auto-field-full", role: "group", "aria-label": "Schedule frequency" },
+          SCHEDULE_MODES.map((mode) => h(
+            Pill,
+            {
+              key: mode.id,
+              type: "button",
+              active: activeMode === mode.id,
+              "aria-pressed": activeMode === mode.id,
+              onClick: () => setMode(mode.id),
+            },
+            mode.label,
+          )),
+        ),
+        activeMode === "minutes"
+          ? h(
+              Field,
+              { label: "Interval", htmlFor: fieldId("interval") },
+              h(
+                "select",
+                {
+                  id: fieldId("interval"),
+                  className: "dsh-auto-select",
+                  value: values.interval,
+                  onChange: (event) => applySimpleValues("minutes", Object.assign({}, values, { interval: Number(event.target.value) })),
+                },
+                MINUTE_INTERVALS.map((minutes) => h("option", { key: minutes, value: minutes }, "Every " + minutes + " minutes")),
+              ),
+            )
+          : null,
+        activeMode === "hourly"
+          ? h(
+              Field,
+              { label: "Minute past the hour", htmlFor: fieldId("hour-minute") },
+              h(
+                "select",
+                {
+                  id: fieldId("hour-minute"),
+                  className: "dsh-auto-select",
+                  value: values.minute,
+                  onChange: (event) => applySimpleValues("hourly", Object.assign({}, values, { minute: Number(event.target.value) })),
+                },
+                HOURLY_MINUTES.map((minute) => h("option", { key: minute, value: minute }, ":" + twoDigits(minute))),
+              ),
+            )
+          : null,
+        ["daily", "weekdays", "weekly"].includes(activeMode)
+          ? h(
+              Field,
+              { label: "Time", htmlFor: fieldId("schedule-time") },
+              h("input", {
+                id: fieldId("schedule-time"),
+                className: "dsh-auto-input",
+                type: "time",
+                value: twoDigits(values.hour) + ":" + twoDigits(values.minute),
+                onChange: (event) => setTime(event.target.value),
+              }),
+            )
+          : null,
+        activeMode === "weekly"
+          ? h(
+              Field,
+              { label: "Day", htmlFor: fieldId("schedule-day") },
+              h(
+                "select",
+                {
+                  id: fieldId("schedule-day"),
+                  className: "dsh-auto-select",
+                  value: values.weekday,
+                  onChange: (event) => applySimpleValues("weekly", Object.assign({}, values, { weekday: event.target.value })),
+                },
+                WEEKDAYS.map((day) => h("option", { key: day.value, value: day.value }, day.label)),
+              ),
+            )
+          : null,
+        h(
+          Field,
+          {
+            label: "Time zone",
+            htmlFor: fieldId("timezone"),
+            required: true,
+            full: activeMode === "weekly" || activeMode === "custom",
+            hint: "Current UTC offsets and daylight-saving changes are handled by the selected IANA time zone.",
+          },
+          h(TimeZonePicker, {
+            id: fieldId("timezone"),
+            value: timezone,
+            onChange: onTimezoneChange,
+          }),
+        ),
+        activeMode === "custom"
+          ? h(
+              Field,
+              {
+                label: "Cron expression",
+                htmlFor: fieldId("cron"),
+                required: true,
+                full: true,
+                hint: "Five fields only. Seconds and hashed H expressions are not supported.",
+              },
+              h("input", {
+                id: fieldId("cron"),
+                className: "dsh-auto-input dsh-auto-cron-input",
+                type: "text",
+                value: cron,
+                spellCheck: false,
+                placeholder: "0 9 * * 1-5",
+                onChange: (event) => {
+                  const nextCron = event.target.value;
+                  customCronRef.current = nextCron;
+                  customCronPinnedRef.current = true;
+                  setValues(scheduleControlValues(nextCron, values));
+                  setForceCustom(true);
+                  onCronChange(nextCron);
+                },
+              }),
+              h(CronFieldGuide, { value: cron }),
+            )
+          : null,
+        h(
+          "div",
+          { className: "dsh-auto-schedule-summary dsh-auto-field-full" },
+          h("span", { className: "dsh-auto-schedule-summary-copy" }, describeSimpleSchedule(summarySchedule, timezone)),
+          h("code", { className: "dsh-auto-schedule-expression", title: displayedCron }, displayedCron),
+        ),
+      );
+    }
+
     function Field(props) {
       const { label, htmlFor, required, hint, full, children } = props;
       return h(
@@ -699,6 +1056,7 @@ window.__ModuleLoader__.load({
       const {
         id,
         value,
+        displayValue,
         onChange,
         optionsForQuery,
         selectedId,
@@ -939,7 +1297,7 @@ window.__ModuleLoader__.load({
             className: "dsh-auto-combobox-input",
             type: "text",
             role: "combobox",
-            value,
+            value: !searching && displayValue !== undefined ? displayValue : value,
             placeholder,
             disabled,
             autoComplete: "off",
@@ -1026,6 +1384,105 @@ window.__ModuleLoader__.load({
       });
     }
 
+    function looksLikeAbsolutePath(value) {
+      const path = String(value || "").trim();
+      return path.charAt(0) === "/" || /^[A-Za-z]:[\\/]/.test(path) || path.startsWith("\\\\");
+    }
+
+    function workspacePathName(path) {
+      const withoutTrailingSeparators = String(path || "").replace(/[\\/]+$/, "");
+      const segments = withoutTrailingSeparators.split(/[\\/]/).filter(Boolean);
+      return segments[segments.length - 1] || String(path || "");
+    }
+
+    function normalizedWorkspaces(workspaces) {
+      const seenPaths = new Set();
+      return (Array.isArray(workspaces) ? workspaces : [])
+        .map((workspace, index) => {
+          if (!workspace || typeof workspace.path !== "string" || workspace.path.trim() === "") return null;
+          const path = workspace.path.trim();
+          if (seenPaths.has(path)) return null;
+          seenPaths.add(path);
+          const rawTitle = typeof workspace.title === "string" ? workspace.title.trim() : "";
+          return {
+            id: String(workspace.workspaceId || workspace.id || "workspace-" + index),
+            path,
+            title: rawTitle || workspacePathName(path),
+            sessionCount: Array.isArray(workspace.sessionIds) ? workspace.sessionIds.length : 0,
+          };
+        })
+        .filter(Boolean);
+    }
+
+    function preferredWorkspacePath(workspaceSnapshot) {
+      const catalog = normalizedWorkspaces(workspaceSnapshot?.items);
+      const recentId = workspaceSnapshot?.recentWorkspaceId;
+      const recent = recentId === undefined
+        ? null
+        : catalog.find((workspace) => workspace.id === String(recentId));
+      return (recent || catalog[0] || {}).path || "";
+    }
+
+    function WorkspacePicker({ id, value, workspaceSnapshot, onChange }) {
+      const catalog = normalizedWorkspaces(workspaceSnapshot?.items);
+      const exactValue = value.trim();
+      const selected = catalog.find((workspace) => workspace.path === exactValue) || null;
+      const custom = exactValue !== "" && selected === null && looksLikeAbsolutePath(exactValue);
+      const options = [
+        ...catalog.map((workspace) => ({
+          id: "workspace:" + workspace.id,
+          value: workspace.path,
+          label: workspace.title,
+          detail: workspace.path + " · " + workspace.sessionCount + (workspace.sessionCount === 1 ? " session" : " sessions"),
+          aliases: [workspace.id, workspacePathName(workspace.path)],
+          Icon: IconFolderClose16,
+        })),
+        ...(custom
+          ? [{
+              id: "custom-workspace:" + exactValue,
+              value: exactValue,
+              label: workspacePathName(exactValue) || exactValue,
+              detail: exactValue + " · Custom absolute path",
+              aliases: [exactValue],
+              custom: true,
+              Icon: IconFolderClose16,
+            }]
+          : []),
+      ];
+      let panelNotice = null;
+      if (workspaceSnapshot?.state === "error") {
+        panelNotice = "Harness workspaces are unavailable. You can still enter an absolute directory path.";
+      } else if (workspaceSnapshot?.phase !== "ready" && catalog.length === 0) {
+        panelNotice = "Loading Harness workspaces. You can still enter an absolute directory path.";
+      }
+      return h(EditableCombobox, {
+        id,
+        value,
+        displayValue: selected ? selected.title : undefined,
+        onChange,
+        optionsForQuery: (query) => comboboxSearchResults(options, query),
+        selectedId: selected ? "workspace:" + selected.id : custom ? "custom-workspace:" + exactValue : null,
+        commitExactValue: (raw) => {
+          const path = raw.trim();
+          return looksLikeAbsolutePath(path) ? path : null;
+        },
+        placeholder: "Choose a Harness workspace or enter a path",
+        Icon: IconFolderClose16,
+        listboxLabel: "Harness workspaces",
+        initialTitle: "Harness workspaces",
+        searchTitle: "Matching workspaces",
+        emptyText: catalog.length === 0
+          ? "No Harness workspaces are registered. Enter an absolute directory path."
+          : "No matching workspaces. Enter an absolute directory path to use it directly.",
+        hintText: "Choose a registered workspace or enter an absolute path without registering it.",
+        resultNoun: "workspace",
+        invalidMessage: "Enter an absolute workspace path.",
+        invalid: exactValue !== "" && !looksLikeAbsolutePath(exactValue),
+        resumeSearch: custom,
+        panelNotice,
+      });
+    }
+
     function providerFallbackName(id) {
       return humanizePresetId(id)
         .replace(/^Openai\b/, "OpenAI")
@@ -1399,7 +1856,7 @@ window.__ModuleLoader__.load({
     }
 
     function JobForm(props) {
-      const { meta, draft, editing, saving, error, onChange, onIdTouched, onSubmit, onCancel } = props;
+      const { meta, workspaceSnapshot, draft, editing, saving, error, errorField, onChange, onIdTouched, onSubmit, onCancel } = props;
       const providers = normalizedProviders(meta && Array.isArray(meta.providers) ? meta.providers : []);
       const providerModels = providers.find((provider) => provider.id === draft.provider);
       const models = providerModels ? providerModels.models : [];
@@ -1415,6 +1872,43 @@ window.__ModuleLoader__.load({
         formPrefixRef.current = nextFormInstancePrefix(reactFormId);
       }
       const fieldId = (name) => formPrefixRef.current + "-" + name;
+      const errorId = fieldId("form-error");
+      const [advancedOpen, setAdvancedOpen] = useState(false);
+      const advancedError = ["id", "timeout", "overlap", "misfire"].includes(errorField);
+      const errorPanelReady = !advancedError || advancedOpen;
+      useEffect(() => {
+        if (!error || !errorField) return undefined;
+        if (!errorPanelReady) {
+          setAdvancedOpen(true);
+          return undefined;
+        }
+        let target = null;
+        let previousInvalid = null;
+        let previousDescribedBy = null;
+        const frame = requestAnimationFrame(() => {
+          target = document.getElementById(fieldId(errorField));
+          if (!target) return;
+          previousInvalid = target.getAttribute("aria-invalid");
+          previousDescribedBy = target.getAttribute("aria-describedby");
+          target.setAttribute("aria-invalid", "true");
+          target.setAttribute("aria-describedby", errorId);
+          target.focus();
+        });
+        return () => {
+          cancelAnimationFrame(frame);
+          if (!target) return;
+          if (previousInvalid === null) target.removeAttribute("aria-invalid");
+          else target.setAttribute("aria-invalid", previousInvalid);
+          if (previousDescribedBy === null) target.removeAttribute("aria-describedby");
+          else target.setAttribute("aria-describedby", previousDescribedBy);
+        };
+      }, [error, errorField, errorPanelReady]);
+      const advancedSummary = [
+        creating ? (draft.id.trim() === "" ? "Automatic job ID" : "ID " + draft.id.trim()) : "ID " + draft.id,
+        (formatTimeout(Number(draft.timeoutMs)) || draft.timeoutMs + "ms") + " timeout",
+        overlapPolicySummary(draft.overlap),
+        draft.misfire === "skip" ? "Skip missed runs" : "Run once after downtime",
+      ].join(" · ");
 
       return h(
         "form",
@@ -1424,259 +1918,327 @@ window.__ModuleLoader__.load({
           noValidate: true,
           "aria-label": creating ? "New automation" : "Edit automation",
         },
-        h("h3", null, creating ? "New automation" : "Edit \u201c" + editing.name + "\u201d"),
         h(
-          "div",
-          { className: "dsh-auto-formgrid" },
+          "header",
+          { className: "dsh-auto-form-header" },
           h(
-            Field,
-            { label: "Name", htmlFor: fieldId("name"), required: true },
-            h("input", {
-              id: fieldId("name"),
-              className: "dsh-auto-input",
-              type: "text",
-              value: draft.name,
-              autoFocus: true,
-              placeholder: "e.g. Morning standup notes",
-              onChange: (event) => onChange("name", event.target.value),
-            }),
+            "span",
+            { className: "dsh-auto-form-heading" },
+            h("h3", null, creating ? "New automation" : "Edit \u201c" + editing.name + "\u201d"),
+            h("p", null, "Configure what runs, when it runs, and which Harness agent executes it."),
           ),
-          creating
-            ? h(
-                Field,
-                { label: "Job id", htmlFor: fieldId("id"), hint: "Lowercase letters, digits and hyphens; auto-derived from the name. Leave blank to let the server generate one." },
-                h("input", {
-                  id: fieldId("id"),
-                  className: "dsh-auto-input",
-                  type: "text",
-                  value: draft.id,
-                  spellCheck: false,
-                  placeholder: "auto",
-                  onChange: (event) => {
-                    onIdTouched();
-                    onChange("id", event.target.value);
-                  },
-                }),
-              )
-            : h(
-                Field,
-                { label: "Job id", htmlFor: fieldId("id"), hint: "Fixed after creation." },
-                h("input", {
-                  id: fieldId("id"),
-                  className: "dsh-auto-input",
-                  type: "text",
-                  value: draft.id,
-                  disabled: true,
-                  spellCheck: false,
-                }),
-              ),
           h(
-            Field,
-            { label: "Cron", htmlFor: fieldId("cron"), required: true, hint: "Five-field cron (minute hour day-of-month month day-of-week)." },
+            "label",
+            { className: "dsh-auto-switch dsh-auto-form-enabled" },
             h("input", {
-              id: fieldId("cron"),
-              className: "dsh-auto-input",
-              type: "text",
-              value: draft.cron,
-              spellCheck: false,
-              onChange: (event) => onChange("cron", event.target.value),
-            }),
-          ),
-          h(
-            Field,
-            {
-              label: "Time zone",
-              htmlFor: fieldId("timezone"),
-              required: true,
-              hint: "Enter an IANA time zone. Current UTC offsets may change with daylight saving time.",
-            },
-            h(TimeZonePicker, {
-              id: fieldId("timezone"),
-              value: draft.timezone,
-              onChange: (value) => onChange("timezone", value),
+              id: fieldId("enabled"),
+              type: "checkbox",
+              role: "switch",
+              checked: draft.enabled,
+              onChange: (event) => onChange("enabled", event.target.checked),
             }),
+            h("span", { className: "dsh-auto-switch-track" }),
+            h("span", { className: "dsh-auto-switch-text" }, draft.enabled ? "Active" : "Paused"),
           ),
+        ),
+        h(
+          FormSection,
+          {
+            title: "Task",
+            description: "Describe the work and choose where the agent should run.",
+            Icon: IconEditOutline16,
+          },
           h(
-            Field,
-            { label: "Enabled", htmlFor: fieldId("enabled") },
+            "div",
+            { className: "dsh-auto-formgrid" },
             h(
-              "label",
-              { className: "dsh-auto-check" },
+              Field,
+              { label: "Name", htmlFor: fieldId("name"), required: true, full: true },
               h("input", {
-                id: fieldId("enabled"),
-                type: "checkbox",
-                checked: draft.enabled,
-                onChange: (event) => onChange("enabled", event.target.checked),
+                id: fieldId("name"),
+                className: "dsh-auto-input",
+                type: "text",
+                value: draft.name,
+                autoFocus: true,
+                placeholder: "e.g. Morning standup notes",
+                onChange: (event) => onChange("name", event.target.value),
               }),
-              h("span", null, "Schedule is active"),
             ),
-          ),
-          h(
-            Field,
-            { label: "Timeout (ms)", htmlFor: fieldId("timeout"), required: true, hint: "Wall-clock limit for each run (1s to 24h)." },
-            h("input", {
-              id: fieldId("timeout"),
-              className: "dsh-auto-input",
-              type: "number",
-              min: MIN_TIMEOUT_MS,
-              max: MAX_TIMEOUT_MS,
-              step: 1000,
-              value: draft.timeoutMs,
-              onChange: (event) => onChange("timeoutMs", event.target.value),
-            }),
-          ),
-          h(
-            Field,
-            { label: "Provider", htmlFor: fieldId("provider"), hint: "Blank uses the current Harness default. You may type an unlisted provider route." },
-            h(ProviderPicker, {
-              id: fieldId("provider"),
-              value: draft.provider,
-              providers,
-              defaultModel: meta?.defaultModel,
-              onChange: (value) => onChange("provider", value),
-            }),
-          ),
-          h(
-            Field,
-            {
-              label: "Model",
-              htmlFor: fieldId("model"),
-              required: draft.provider !== "",
-              hint: draft.provider === ""
-                ? "Set a provider first, or leave both blank for the Harness default."
-                : "Choose a discovered model or type an adapter-supported model id.",
-            },
-            h("input", {
-              id: fieldId("model"),
-              className: "dsh-auto-input",
-              type: "text",
-              list: fieldId("model-list"),
-              value: draft.model,
-              spellCheck: false,
-              placeholder: draft.provider === "" ? "Harness default" : "Model id",
-              disabled: draft.provider === "",
-              onChange: (event) => onChange("model", event.target.value),
-            }),
             h(
-              "datalist",
-              { id: fieldId("model-list") },
-              models.map((model) => h("option", {
-                key: model.id,
-                value: model.id,
-                label: model.name === model.id ? undefined : model.name,
-              })),
+              Field,
+              {
+                label: "Prompt",
+                htmlFor: fieldId("prompt"),
+                required: true,
+                full: true,
+                hint: "Instructions sent to a fresh agent. Prompts are not copied into run-history summaries.",
+              },
+              h("textarea", {
+                id: fieldId("prompt"),
+                className: "dsh-auto-textarea dsh-auto-prompt",
+                value: draft.prompt,
+                placeholder: "Summarize yesterday's progress and list today's priorities\u2026",
+                onChange: (event) => onChange("prompt", event.target.value),
+              }),
+            ),
+            h(
+              Field,
+              {
+                label: "Workspace",
+                htmlFor: fieldId("cwd"),
+                required: true,
+                full: true,
+                hint: "Choose a Harness workspace or enter the absolute directory where the agent runs.",
+              },
+              h(WorkspacePicker, {
+                id: fieldId("cwd"),
+                value: draft.cwd,
+                workspaceSnapshot,
+                onChange: (value) => onChange("cwd", value),
+              }),
             ),
           ),
+        ),
+        h(
+          FormSection,
+          {
+            title: "Schedule",
+            description: "Choose a common pattern, or switch to Custom for a five-field cron expression.",
+            Icon: IconGlobeOutline14,
+          },
           h(
-            Field,
-            { label: "Reasoning effort", htmlFor: fieldId("effort"), hint: "Default follows the selected model. Custom adapter-owned IDs remain supported." },
-            h(ReasoningEffortPicker, {
-              id: fieldId("effort"),
-              value: draft.reasoningEffort,
-              provider: draft.provider,
-              model: draft.model,
-              defaultModel: meta?.defaultModel,
-              onChange: (value) => onChange("reasoningEffort", value),
-            }),
-          ),
-          h(
-            Field,
-            { label: "Agent preset", htmlFor: fieldId("preset"), hint: "Uses the current Harness default when not explicitly selected." },
-            h(AgentPresetPicker, {
-              id: fieldId("preset"),
-              value: draft.agentPreset,
-              presets: agentPresets,
-              onChange: (value) => onChange("agentPreset", value),
-            }),
-          ),
-          h(
-            Field,
-            {
-              label: "Permission preset",
-              htmlFor: fieldId("permission"),
-              required: true,
-              hint: permissionPresetPresentation(draft.permissionPreset).detail,
-            },
-            h(PermissionPresetPicker, {
-              id: fieldId("permission"),
-              value: draft.permissionPreset,
-              presets: permissionPresets,
-              onChange: (value) => onChange("permissionPreset", value),
+            "div",
+            { className: "dsh-auto-formgrid dsh-auto-schedule-grid" },
+            h(ScheduleEditor, {
+              fieldId,
+              cron: draft.cron,
+              timezone: draft.timezone,
+              onCronChange: (value) => onChange("cron", value),
+              onTimezoneChange: (value) => onChange("timezone", value),
             }),
           ),
+        ),
+        h(
+          FormSection,
+          {
+            title: "Agent & access",
+            description: "Select the model, agent behavior, and filesystem permissions for each fresh run.",
+            Icon: IconAgentPresetOutline16,
+          },
           h(
-            Field,
-            { label: "Overlap policy", htmlFor: fieldId("overlap"), full: true, hint: "What happens when a scheduled run fires while another run for the same job is still active." },
+            "div",
+            { className: "dsh-auto-formgrid" },
             h(
-              "select",
+              Field,
+              { label: "Provider", htmlFor: fieldId("provider"), hint: "Blank uses the current Harness default. Custom provider routes remain supported." },
+              h(ProviderPicker, {
+                id: fieldId("provider"),
+                value: draft.provider,
+                providers,
+                defaultModel: meta?.defaultModel,
+                onChange: (value) => onChange("provider", value),
+              }),
+            ),
+            h(
+              Field,
               {
-                id: fieldId("overlap"),
-                className: "dsh-auto-select",
-                value: draft.overlap,
-                onChange: (event) => onChange("overlap", event.target.value),
+                label: "Model",
+                htmlFor: fieldId("model"),
+                required: draft.provider !== "",
+                hint: draft.provider === ""
+                  ? "Set a provider first, or leave both blank for the Harness default."
+                  : "Choose a discovered model or type an adapter-supported model id.",
               },
-              OVERLAP_OPTIONS.map((option) => h("option", { key: option.value, value: option.value }, option.label)),
+              h("input", {
+                id: fieldId("model"),
+                className: "dsh-auto-input",
+                type: "text",
+                list: fieldId("model-list"),
+                value: draft.model,
+                spellCheck: false,
+                placeholder: draft.provider === "" ? "Harness default" : "Model id",
+                disabled: draft.provider === "",
+                onChange: (event) => onChange("model", event.target.value),
+              }),
+              h(
+                "datalist",
+                { id: fieldId("model-list") },
+                models.map((model) => h("option", {
+                  key: model.id,
+                  value: model.id,
+                  label: model.name === model.id ? undefined : model.name,
+                })),
+              ),
+            ),
+            h(
+              Field,
+              { label: "Reasoning effort", htmlFor: fieldId("effort"), hint: "Default follows the selected model. Custom adapter-owned IDs remain supported." },
+              h(ReasoningEffortPicker, {
+                id: fieldId("effort"),
+                value: draft.reasoningEffort,
+                provider: draft.provider,
+                model: draft.model,
+                defaultModel: meta?.defaultModel,
+                onChange: (value) => onChange("reasoningEffort", value),
+              }),
+            ),
+            h(
+              Field,
+              { label: "Agent preset", htmlFor: fieldId("preset"), hint: "Uses the current Harness default when not explicitly selected." },
+              h(AgentPresetPicker, {
+                id: fieldId("preset"),
+                value: draft.agentPreset,
+                presets: agentPresets,
+                onChange: (value) => onChange("agentPreset", value),
+              }),
             ),
-          ),
-          h(
-            Field,
-            { label: "Misfire policy", htmlFor: fieldId("misfire"), hint: "How a missed occurrence is handled after the scheduler is back." },
             h(
-              "select",
+              Field,
               {
-                id: fieldId("misfire"),
-                className: "dsh-auto-select",
-                value: draft.misfire,
-                onChange: (event) => onChange("misfire", event.target.value),
+                label: "Permission preset",
+                htmlFor: fieldId("permission"),
+                required: true,
+                full: true,
+                hint: permissionPresetPresentation(draft.permissionPreset).detail,
               },
-              MISFIRE_OPTIONS.map((option) => h("option", { key: option.value, value: option.value }, option.label)),
+              h(PermissionPresetPicker, {
+                id: fieldId("permission"),
+                value: draft.permissionPreset,
+                presets: permissionPresets,
+                onChange: (value) => onChange("permissionPreset", value),
+              }),
             ),
           ),
-          h(
-            Field,
-            { label: "Working directory", htmlFor: fieldId("cwd"), required: true, full: true, hint: "Absolute project directory the agent runs in." },
-            h("input", {
-              id: fieldId("cwd"),
-              className: "dsh-auto-input",
-              type: "text",
-              value: draft.cwd,
-              spellCheck: false,
-              placeholder: "/home/you/workspace/project",
-              onChange: (event) => onChange("cwd", event.target.value),
-            }),
-          ),
-          h(
-            Field,
-            { label: "Prompt", htmlFor: fieldId("prompt"), required: true, full: true, hint: "Instructions for the agent run. Prompts are never shown in run history." },
-            h("textarea", {
-              id: fieldId("prompt"),
-              className: "dsh-auto-textarea",
-              value: draft.prompt,
-              placeholder: "Summarize yesterday's progress and list today's priorities\u2026",
-              onChange: (event) => onChange("prompt", event.target.value),
-            }),
-          ),
         ),
-        error
-          ? h("p", { className: "dsh-auto-formerror", role: "alert" }, error)
-          : null,
         h(
-          "div",
-          { className: "dsh-auto-formactions" },
+          "section",
+          { className: "dsh-auto-advanced", "data-open": advancedOpen ? "true" : undefined },
           h(
-            Button,
+            "button",
             {
-              type: "submit",
-              variant: "primary",
-              icon: saving ? null : h(IconCheckOutline16),
-              disabled: saving,
+              type: "button",
+              className: "dsh-auto-advanced-trigger",
+              "aria-expanded": advancedOpen,
+              "aria-controls": fieldId("advanced-content"),
+              onClick: () => setAdvancedOpen((open) => !open),
             },
-            saving ? "Saving\u2026" : creating ? "Create automation" : "Save changes",
+            h("span", { className: "dsh-auto-form-section-icon", "aria-hidden": "true" }, h(IconSettingsOutline16)),
+            h(
+              "span",
+              { className: "dsh-auto-advanced-copy" },
+              h("span", { className: "dsh-auto-form-section-title" }, "Advanced"),
+              h("span", { className: "dsh-auto-advanced-summary" }, advancedSummary),
+            ),
+            h(
+              "span",
+              { className: "dsh-auto-advanced-chevron" + (advancedOpen ? " dsh-auto-advanced-chevron-open" : ""), "aria-hidden": "true" },
+              h(IconChevronDownOutline14),
+            ),
           ),
           h(
-            Button,
-            { type: "button", variant: "outline", onClick: onCancel, disabled: saving },
-            "Cancel",
+            "div",
+            {
+              id: fieldId("advanced-content"),
+              className: "dsh-auto-formgrid dsh-auto-advanced-content",
+              hidden: !advancedOpen,
+            },
+                creating
+                  ? h(
+                      Field,
+                      { label: "Job ID", htmlFor: fieldId("id"), hint: "Auto-derived from the name. Use lowercase letters, digits, and hyphens." },
+                      h("input", {
+                        id: fieldId("id"),
+                        className: "dsh-auto-input",
+                        type: "text",
+                        value: draft.id,
+                        spellCheck: false,
+                        placeholder: "auto",
+                        onChange: (event) => {
+                          onIdTouched();
+                          onChange("id", event.target.value);
+                        },
+                      }),
+                    )
+                  : h(
+                      Field,
+                      { label: "Job ID", htmlFor: fieldId("id"), hint: "Fixed after creation." },
+                      h("input", {
+                        id: fieldId("id"),
+                        className: "dsh-auto-input",
+                        type: "text",
+                        value: draft.id,
+                        disabled: true,
+                        spellCheck: false,
+                      }),
+                    ),
+                h(
+                  Field,
+                  { label: "Timeout (ms)", htmlFor: fieldId("timeout"), required: true, hint: "Wall-clock limit for each run (1s to 24h)." },
+                  h("input", {
+                    id: fieldId("timeout"),
+                    className: "dsh-auto-input",
+                    type: "number",
+                    min: MIN_TIMEOUT_MS,
+                    max: MAX_TIMEOUT_MS,
+                    step: 1000,
+                    value: draft.timeoutMs,
+                    onChange: (event) => onChange("timeoutMs", event.target.value),
+                  }),
+                ),
+                h(
+                  Field,
+                  { label: "Overlap policy", htmlFor: fieldId("overlap"), hint: OVERLAP_OPTIONS.find((option) => option.value === draft.overlap)?.hint },
+                  h(
+                    "select",
+                    {
+                      id: fieldId("overlap"),
+                      className: "dsh-auto-select",
+                      value: draft.overlap,
+                      onChange: (event) => onChange("overlap", event.target.value),
+                    },
+                    OVERLAP_OPTIONS.map((option) => h("option", { key: option.value, value: option.value }, option.label)),
+                  ),
+                ),
+                h(
+                  Field,
+                  { label: "Misfire policy", htmlFor: fieldId("misfire"), hint: MISFIRE_OPTIONS.find((option) => option.value === draft.misfire)?.hint },
+                  h(
+                    "select",
+                    {
+                      id: fieldId("misfire"),
+                      className: "dsh-auto-select",
+                      value: draft.misfire,
+                      onChange: (event) => onChange("misfire", event.target.value),
+                    },
+                    MISFIRE_OPTIONS.map((option) => h("option", { key: option.value, value: option.value }, option.label)),
+                  ),
+                ),
+          ),
+        ),
+        h(
+          "footer",
+          { className: "dsh-auto-form-footer" },
+          error
+            ? h("p", { id: errorId, className: "dsh-auto-formerror", role: "alert" }, error)
+            : null,
+          h(
+            "div",
+            { className: "dsh-auto-formactions" },
+            h(
+              Button,
+              {
+                type: "submit",
+                variant: "primary",
+                icon: saving ? null : h(IconCheckOutline16),
+                disabled: saving,
+              },
+              saving ? "Saving\u2026" : creating ? "Create automation" : "Save changes",
+            ),
+            h(
+              Button,
+              { type: "button", variant: "outline", onClick: onCancel, disabled: saving },
+              "Cancel",
+            ),
           ),
         ),
       );
@@ -1934,7 +2496,21 @@ window.__ModuleLoader__.load({
       );
     }
 
-    function AutomationsSection({ centerMode = false } = {}) {
+    function useHarnessWorkspaceSnapshot(workspaceRuntime) {
+      const list = workspaceRuntime?.list;
+      const subscribe = useCallback(
+        (listener) => list ? list.subscribe(listener) : () => {},
+        [list],
+      );
+      const getSnapshot = useCallback(
+        () => list ? list.getSnapshot() : EMPTY_WORKSPACE_SNAPSHOT,
+        [list],
+      );
+      return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+    }
+
+    function AutomationsSection({ centerMode = false, workspaceRuntime = null } = {}) {
+      const workspaceSnapshot = useHarnessWorkspaceSnapshot(workspaceRuntime);
       const [meta, setMeta] = useState(null);
       const [snapshot, setSnapshot] = useState(null);
       const [loading, setLoading] = useState(true);
@@ -1946,6 +2522,7 @@ window.__ModuleLoader__.load({
       const [editing, setEditing] = useState(null);
       const [draft, setDraft] = useState(() => emptyDraft(null));
       const [formError, setFormError] = useState(null);
+      const [formErrorField, setFormErrorField] = useState(null);
       const [confirmDeleteId, setConfirmDeleteId] = useState(null);
       const [confirmCancelId, setConfirmCancelId] = useState(null);
 
@@ -1953,6 +2530,7 @@ window.__ModuleLoader__.load({
       const pollRef = useRef(false);
       const hasDataRef = useRef(false);
       const idTouchedRef = useRef(false);
+      const workspaceTouchedRef = useRef(false);
       const flashTimerRef = useRef(null);
 
       const loadMeta = useCallback(async () => {
@@ -2098,16 +2676,20 @@ window.__ModuleLoader__.load({
       const openCreate = useCallback(() => {
         setEditing(null);
         idTouchedRef.current = false;
-        setDraft(emptyDraft(meta));
+        workspaceTouchedRef.current = false;
+        setDraft(Object.assign(emptyDraft(meta), { cwd: preferredWorkspacePath(workspaceSnapshot) }));
         setFormError(null);
+        setFormErrorField(null);
         setFormOpen(true);
-      }, [meta]);
+      }, [meta, workspaceSnapshot]);
 
       const openEdit = useCallback((job) => {
         setEditing(job);
         idTouchedRef.current = true;
+        workspaceTouchedRef.current = true;
         setDraft(draftFromJob(job));
         setFormError(null);
+        setFormErrorField(null);
         setFormOpen(true);
       }, []);
 
@@ -2115,10 +2697,21 @@ window.__ModuleLoader__.load({
         setFormOpen(false);
         setEditing(null);
         setFormError(null);
+        setFormErrorField(null);
       }, []);
 
+      useEffect(() => {
+        if (!formOpen || editing !== null || workspaceTouchedRef.current || draft.cwd !== "") return;
+        const preferred = preferredWorkspacePath(workspaceSnapshot);
+        if (preferred === "") return;
+        setDraft((previous) => previous.cwd === "" ? Object.assign({}, previous, { cwd: preferred }) : previous);
+      }, [formOpen, editing, draft.cwd, workspaceSnapshot]);
+
       const handleDraftChange = useCallback(
         (key, value) => {
+          if (key === "cwd") workspaceTouchedRef.current = true;
+          setFormError(null);
+          setFormErrorField(null);
           setDraft((previous) => {
             let next = Object.assign({}, previous, { [key]: value });
             if (key === "name" && editing === null && !idTouchedRef.current) {
@@ -2143,44 +2736,52 @@ window.__ModuleLoader__.load({
         async (event) => {
           event.preventDefault();
           const creating = editing === null;
+          const fail = (field, message) => {
+            setFormErrorField(field);
+            setFormError(message);
+          };
 
           const name = draft.name.trim();
-          if (name === "") return setFormError("Give the automation a name.");
+          if (name === "") return fail("name", "Give the automation a name.");
           const cron = draft.cron.trim();
-          if (cron === "") return setFormError("A cron expression is required, e.g. 0 9 * * 1-5.");
+          if (cron === "") return fail("cron", "A cron expression is required, e.g. 0 9 * * 1-5.");
+          if (cronFields(cron).length !== 5) {
+            return fail("cron", "Cron needs exactly five fields: minute, hour, day, month, and weekday.");
+          }
           const timezone = draft.timezone.trim();
-          if (timezone === "") return setFormError("A timezone is required.");
+          if (timezone === "") return fail("timezone", "A timezone is required.");
           const cwd = draft.cwd.trim();
-          if (cwd === "") return setFormError("The working directory is required.");
-          const looksAbsolute = cwd.charAt(0) === "/" || /^[A-Za-z]:[\\/]/.test(cwd) || cwd.startsWith("\\\\");
-          if (!looksAbsolute) {
-            return setFormError("The working directory must be an absolute filesystem path.");
+          if (cwd === "") return fail("cwd", "A workspace is required.");
+          if (!looksLikeAbsolutePath(cwd)) {
+            return fail("cwd", "The workspace must be an absolute filesystem path.");
           }
           const prompt = draft.prompt.trim();
-          if (prompt === "") return setFormError("A prompt is required.");
+          if (prompt === "") return fail("prompt", "A prompt is required.");
           const timeoutMs = Number(draft.timeoutMs);
           if (!Number.isSafeInteger(timeoutMs) || timeoutMs < MIN_TIMEOUT_MS || timeoutMs > MAX_TIMEOUT_MS) {
-            return setFormError(
+            return fail(
+              "timeout",
               "Timeout must be a whole number of milliseconds between " + MIN_TIMEOUT_MS + " and " + MAX_TIMEOUT_MS + ".",
             );
           }
           const provider = draft.provider.trim();
           const model = draft.model.trim();
           if (provider !== "" && model === "") {
-            return setFormError("Pick a model for the chosen provider (or leave both blank for the Harness default).");
+            return fail("model", "Pick a model for the chosen provider (or leave both blank for the Harness default).");
           }
           if (provider === "" && model !== "") {
-            return setFormError("A model needs a provider (or leave both blank for the Harness default).");
+            return fail("provider", "A model needs a provider (or leave both blank for the Harness default).");
           }
           let id = "";
           if (creating) {
             id = draft.id.trim().toLowerCase();
             if (id !== "" && !JOB_ID_PATTERN.test(id)) {
-              return setFormError("Job id must match [a-z0-9][a-z0-9-]{0,62} (lowercase letters, digits, hyphens).");
+              return fail("id", "Job id must match [a-z0-9][a-z0-9-]{0,62} (lowercase letters, digits, hyphens).");
             }
           }
           const spec = buildSpec(draft);
           setFormError(null);
+          setFormErrorField(null);
           setBusyKey("save", true);
           try {
             if (creating) {
@@ -2198,7 +2799,9 @@ window.__ModuleLoader__.load({
             flashMessage("success", creating ? "Automation created." : "Automation updated.");
             closeForm();
           } catch (error) {
-            setFormError(errMessage(error));
+            const message = errMessage(error);
+            setFormErrorField(inferFormErrorField(message));
+            setFormError(message);
           } finally {
             setBusyKey("save", false);
           }
@@ -2255,11 +2858,14 @@ window.__ModuleLoader__.load({
           : null,
         formOpen
           ? h(JobForm, {
+              key: editing === null ? "create" : "edit:" + editing.id,
               meta,
+              workspaceSnapshot,
               draft,
               editing,
               saving: busy.save === true,
               error: formError,
+              errorField: formErrorField,
               onChange: handleDraftChange,
               onIdTouched: handleIdTouched,
               onSubmit: handleSubmit,
@@ -2425,7 +3031,7 @@ window.__ModuleLoader__.load({
       );
     }
 
-    function AutomationsWorkspace({ disclosure }) {
+    function AutomationsWorkspace({ disclosure, workspaceRuntime }) {
       const workspaceRef = useRef(null);
       const titleId = useId();
 
@@ -2473,7 +3079,7 @@ window.__ModuleLoader__.load({
             "Exit Automations",
           ),
         ),
-        h("div", { className: "dsh-auto-workspace-scroll" }, h(AutomationsSection, { centerMode: true })),
+        h("div", { className: "dsh-auto-workspace-scroll" }, h(AutomationsSection, { centerMode: true, workspaceRuntime })),
       );
     }
 
@@ -2513,6 +3119,7 @@ window.__ModuleLoader__.load({
       ".dsh-auto-input::placeholder,.dsh-auto-textarea::placeholder{color:var(--dsh-auto-caption);}",
       ".dsh-auto-select option{background:var(--dsh-auto-input-bg);color:var(--dsh-auto-text);}",
       ".dsh-auto-input:focus-visible,.dsh-auto-select:focus-visible,.dsh-auto-textarea:focus-visible{outline:none;border-color:var(--dsh-auto-accent);box-shadow:0 0 0 2px color-mix(in srgb,var(--dsh-auto-accent) 18%,transparent);}",
+      ".dsh-auto-input[aria-invalid=\"true\"],.dsh-auto-select[aria-invalid=\"true\"],.dsh-auto-textarea[aria-invalid=\"true\"]{border-color:var(--dsh-auto-danger);}",
       ".dsh-auto-input:disabled,.dsh-auto-select:disabled,.dsh-auto-textarea:disabled{opacity:1;color:var(--dsh-auto-muted);background:var(--dsh-auto-surface-active);cursor:default;}",
       ".dsh-auto-picker-root{width:100%;display:flex;}",
       ".dsh-auto-picker-trigger{appearance:none;width:100%;height:34px;padding:0 9px;border:1px solid var(--dsh-auto-border);border-radius:8px;background:var(--dsh-auto-input-bg);color:var(--dsh-auto-text);display:flex;align-items:center;gap:8px;font-family:inherit;font-size:13px;line-height:20px;text-align:left;cursor:pointer;}",
@@ -2558,16 +3165,50 @@ window.__ModuleLoader__.load({
       ".dsh-auto-permission-glyph-danger{color:var(--dsh-auto-danger);}",
       ".dsh-auto-permission-glyph-custom{color:var(--dsh-auto-muted);}",
       ".dsh-auto-textarea{resize:vertical;min-height:110px;}",
+      ".dsh-auto-prompt{min-height:142px;line-height:1.55;}",
       ".dsh-auto-check{display:inline-flex;align-items:center;gap:8px;font-size:13px;cursor:pointer;min-height:34px;}",
       ".dsh-auto-check input{width:16px;height:16px;margin:0;accent-color:var(--dsh-auto-accent);cursor:pointer;}",
-      ".dsh-auto-form{border:1px solid var(--dsh-auto-border);border-radius:14px;padding:16px;background:var(--dsh-auto-surface);display:flex;flex-direction:column;gap:14px;}",
-      ".dsh-auto-form h3{margin:0;font-size:15px;font-weight:600;}",
-      ".dsh-auto-formgrid{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:12px;}",
-      ".dsh-auto-field{display:flex;flex-direction:column;gap:4px;min-width:0;}",
+      ".dsh-auto-form{box-sizing:border-box;width:min(100%,760px);margin:0 auto;padding:0 0 4px;background:transparent;display:flex;flex-direction:column;gap:16px;}",
+      ".dsh-auto-form-header{display:flex;align-items:flex-start;justify-content:space-between;gap:16px;padding:2px 2px 0;}",
+      ".dsh-auto-form-heading{min-width:0;display:flex;flex-direction:column;gap:3px;}",
+      ".dsh-auto-form h3{margin:0;font-size:17px;font-weight:600;line-height:24px;}",
+      ".dsh-auto-form-heading p{margin:0;color:var(--dsh-auto-muted);font-size:12px;line-height:18px;}",
+      ".dsh-auto-form-enabled{flex:none;margin-top:2px;padding:5px 8px;border:1px solid var(--dsh-auto-border);border-radius:999px;background:var(--dsh-auto-surface);}",
+      ".dsh-auto-form-section,.dsh-auto-advanced{border:1px solid var(--dsh-auto-border);border-radius:14px;background:var(--dsh-auto-surface);box-shadow:0 1px 1px color-mix(in srgb,var(--dsh-auto-text) 4%,transparent);}",
+      ".dsh-auto-form-section{padding:16px;display:flex;flex-direction:column;gap:15px;}",
+      ".dsh-auto-form-section-head{display:flex;align-items:flex-start;gap:10px;}",
+      ".dsh-auto-form-section-icon{width:30px;height:30px;flex:none;border-radius:9px;display:inline-flex;align-items:center;justify-content:center;color:var(--dsh-auto-accent);background:color-mix(in srgb,var(--dsh-auto-accent) 10%,transparent);}",
+      ".dsh-auto-form-section-copy{min-width:0;display:flex;flex-direction:column;gap:1px;}",
+      ".dsh-auto-form-section-title{margin:0;color:var(--dsh-auto-text);font-size:14px;font-weight:600;line-height:20px;}",
+      ".dsh-auto-form-section-description{margin:0;color:var(--dsh-auto-muted);font-size:11px;line-height:17px;}",
+      ".dsh-auto-formgrid{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:14px 12px;}",
+      ".dsh-auto-field{display:flex;flex-direction:column;gap:5px;min-width:0;}",
       ".dsh-auto-field-full{grid-column:1/-1;}",
       ".dsh-auto-label{font-size:12px;font-weight:500;color:var(--dsh-auto-text-secondary);}",
       ".dsh-auto-required{color:var(--dsh-auto-danger);}",
       ".dsh-auto-hint{margin:0;font-size:11px;line-height:1.45;color:var(--dsh-auto-muted);}",
+      ".dsh-auto-schedule-modes{display:flex;align-items:center;gap:6px;flex-wrap:wrap;}",
+      ".dsh-auto-schedule-summary{min-height:42px;padding:9px 11px;border:1px solid color-mix(in srgb,var(--dsh-auto-accent) 20%,var(--dsh-auto-border));border-radius:10px;background:color-mix(in srgb,var(--dsh-auto-accent) 6%,var(--dsh-auto-input-bg));display:flex;align-items:center;justify-content:space-between;gap:10px;}",
+      ".dsh-auto-schedule-summary-copy{min-width:0;color:var(--dsh-auto-text-secondary);font-size:12px;font-weight:500;line-height:18px;}",
+      ".dsh-auto-schedule-expression{min-width:0;max-width:100%;flex:none;padding:2px 6px;border-radius:5px;background:var(--dsw-alias-interactive-bg-hover,rgba(38,49,72,.06));color:var(--dsh-auto-muted);font-size:11px;line-height:17px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;}",
+      ".dsh-auto-cron-input{font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;font-variant-numeric:tabular-nums;letter-spacing:.02em;}",
+      ".dsh-auto-cron-guide{display:grid;grid-template-columns:repeat(5,minmax(0,1fr));gap:6px;margin-top:3px;}",
+      ".dsh-auto-cron-guide-field{min-width:0;padding:7px 6px;border:1px solid var(--dsh-auto-border);border-radius:8px;background:var(--dsh-auto-input-bg);text-align:center;display:flex;flex-direction:column;align-items:center;gap:1px;}",
+      ".dsh-auto-cron-guide-value{max-width:100%;overflow:hidden;text-overflow:ellipsis;color:var(--dsh-auto-text);font-size:12px;font-weight:600;line-height:17px;}",
+      ".dsh-auto-cron-guide-label{color:var(--dsh-auto-text-secondary);font-size:10px;font-weight:500;line-height:14px;}",
+      ".dsh-auto-cron-guide-range{color:var(--dsh-auto-caption);font-size:9px;line-height:12px;}",
+      ".dsh-auto-cron-syntax{margin:0;color:var(--dsh-auto-muted);font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;font-size:10px;line-height:16px;}",
+      ".dsh-auto-advanced{overflow:hidden;}",
+      ".dsh-auto-advanced-trigger{box-sizing:border-box;width:100%;min-height:62px;padding:13px 15px;border:0;background:transparent;color:inherit;text-align:left;font:inherit;display:flex;align-items:center;gap:10px;cursor:pointer;}",
+      ".dsh-auto-advanced-trigger:hover{background:var(--dsw-alias-interactive-bg-hover,rgba(38,49,72,.06));}",
+      ".dsh-auto-advanced-trigger:focus-visible{outline:2px solid var(--dsh-auto-accent);outline-offset:-2px;border-radius:13px;}",
+      ".dsh-auto-advanced-copy{min-width:0;flex:1;display:flex;flex-direction:column;gap:1px;}",
+      ".dsh-auto-advanced-summary{overflow:hidden;text-overflow:ellipsis;white-space:nowrap;color:var(--dsh-auto-muted);font-size:11px;line-height:17px;}",
+      ".dsh-auto-advanced-chevron{flex:none;color:var(--dsh-auto-muted);transition:transform .15s ease;}",
+      ".dsh-auto-advanced-chevron-open{transform:rotate(180deg);}",
+      ".dsh-auto-advanced-content{margin:0 15px;padding:15px 0;border-top:1px solid var(--dsh-auto-border);}",
+      ".dsh-auto-advanced-content[hidden]{display:none;}",
+      ".dsh-auto-form-footer{position:sticky;z-index:4;bottom:8px;align-self:flex-end;max-width:100%;padding:9px 10px;border:1px solid var(--dsh-auto-border);border-radius:12px;background:var(--dsh-auto-surface);box-shadow:var(--dsw-shadow-lv2,0 6px 18px rgba(15,17,21,.12));display:flex;flex-direction:column;gap:8px;}",
       ".dsh-auto-formerror{margin:0;padding:8px 10px;border-radius:8px;background:color-mix(in srgb,var(--dsh-auto-danger) 10%,transparent);color:var(--dsh-auto-danger);font-size:12px;line-height:1.45;}",
       ".dsh-auto-formactions{display:flex;gap:8px;justify-content:flex-end;align-items:center;flex-wrap:wrap;}",
       ".dsh-auto-jobs{display:flex;flex-direction:column;gap:10px;}",
@@ -2617,8 +3258,8 @@ window.__ModuleLoader__.load({
       "@keyframes dsh-auto-pulse{0%,100%{opacity:1}50%{opacity:.35}}",
       ".dsh-auto-empty,.dsh-auto-loading,.dsh-auto-error{padding:22px 16px;text-align:center;border:1px dashed var(--dsh-auto-border);border-radius:12px;font-size:13px;color:var(--dsh-auto-text-secondary);}",
       ".dsh-auto-error{color:var(--dsh-auto-danger);display:flex;flex-direction:column;gap:10px;align-items:center;}",
-      "@container dsh-auto-workspace (max-width:680px){.dsh-auto-formgrid{grid-template-columns:1fr;}.dsh-auto-card-head{flex-direction:column;align-items:flex-start;}.dsh-auto-run-name{max-width:150px;}}",
-      "@media (max-width:640px){.dsh-auto-workspace-toolbar{padding-inline:8px;}.dsh-auto-workspace-scroll{padding:16px 14px 28px;}.dsh-auto-formgrid{grid-template-columns:1fr;}.dsh-auto-card-head{flex-direction:column;align-items:flex-start;}.dsh-auto-run-name{max-width:150px;}}",
+      "@container dsh-auto-workspace (max-width:680px){.dsh-auto-formgrid{grid-template-columns:1fr;}.dsh-auto-form-header{align-items:center;}.dsh-auto-schedule-summary{align-items:flex-start;flex-direction:column;}.dsh-auto-card-head{flex-direction:column;align-items:flex-start;}.dsh-auto-run-name{max-width:150px;}}",
+      "@media (max-width:640px){.dsh-auto-workspace-toolbar{padding-inline:8px;}.dsh-auto-workspace-scroll{padding:16px 14px 28px;}.dsh-auto-formgrid{grid-template-columns:1fr;}.dsh-auto-form-header{align-items:center;}.dsh-auto-form-section{padding:14px;}.dsh-auto-advanced-trigger{padding:12px 13px;}.dsh-auto-advanced-content{margin-inline:13px;}.dsh-auto-schedule-summary{align-items:flex-start;flex-direction:column;}.dsh-auto-cron-guide{gap:4px;}.dsh-auto-cron-guide-field{padding-inline:3px;}.dsh-auto-card-head{flex-direction:column;align-items:flex-start;}.dsh-auto-run-name{max-width:150px;}}",
     ].join("\n");
 
     function apply(ctx) {
@@ -2637,7 +3278,7 @@ window.__ModuleLoader__.load({
           disposeCenter = ctx.slots.register({
             name: "conversation",
             priority: -200,
-            inject: () => ({ disclosure }),
+            inject: () => ({ disclosure, workspaceRuntime: ctx.workspaces }),
           }, AutomationsWorkspace);
         } catch (error) {
           console.error("dsh automations: could not mount center workspace", error);
@@ -2681,6 +3322,7 @@ window.__ModuleLoader__.load({
         id: "automations",
         order: 25,
         label: "Automations",
+        inject: () => ({ workspaceRuntime: ctx.workspaces }),
       }, AutomationsSection));
       ctx.slots.inject("sidebar.footer.action", () => ctx.slots.register({
         name: "sidebar.footer.action",
@@ -2695,13 +3337,26 @@ window.__ModuleLoader__.load({
     exports.permissionPresetPresentation = permissionPresetPresentation;
     exports.PermissionPresetPicker = PermissionPresetPicker;
     exports.EditableCombobox = EditableCombobox;
+    exports.ScheduleEditor = ScheduleEditor;
+    exports.WorkspacePicker = WorkspacePicker;
     exports.ProviderPicker = ProviderPicker;
     exports.ReasoningEffortPicker = ReasoningEffortPicker;
     exports.TimeZonePicker = TimeZonePicker;
     exports.__testing = Object.freeze({
       nextFormInstancePrefix,
       canonicalTimezone,
+      cronFields,
+      simpleSchedule,
+      scheduleControlValues,
+      cronForSimpleSchedule,
+      scheduleModeTransition,
+      describeSimpleSchedule,
+      inferFormErrorField,
+      overlapPolicySummary,
       comboboxSearchResults,
+      looksLikeAbsolutePath,
+      normalizedWorkspaces,
+      preferredWorkspacePath,
       normalizedProviders,
       providerFallbackName,
       reasoningEffortsForState,