@abot-ai/runtime 1.5.0 → 1.7.0

package/dist/src/web-ui/app/components/automations/chat-run-projection.js

@@ -0,0 +1,280 @@
+import { createEventRefresh } from "../../lib/event-refresh.js";
+import { createAutomationLiveView } from "./live-view.js";
+import { renderAutomationRun } from "./run.js";
+import { focusSelectedAutomationStep } from "./run-steps-view.js";
+import { selectedAutomationRunStepId } from "./run-step-selection.js";
+
+function errorText(error) {
+  const code = typeof error?.code === "string" ? `${error.code} · ` : "";
+  return `${code}${error instanceof Error ? error.message : String(error)}`;
+}
+
+function isRunChange(message, environmentId, runId) {
+  if (message?.type !== "event" || message.environment !== environmentId) return false;
+  if (typeof message.name !== "string" || !message.name.startsWith("automation.")) return false;
+  return typeof message.runId !== "string" || !message.runId || message.runId === runId;
+}
+
+function hasSelectedStepEvidence(response, runId, nodeId) {
+  return response?.evidence?.runId === runId && response.evidence.nodeId === nodeId;
+}
+
+export function createAutomationChatRunProjection({
+  dom, client, getEnvironmentId, onNavigationChange, returnToStudio,
+  isVisible = () => document.visibilityState !== "hidden",
+}) {
+  const liveView = createAutomationLiveView(dom.automationChatRunPanel);
+  let runId = "";
+  let run = null;
+  let error = "";
+  let loading = false;
+  let selectedNodeId = "";
+  let stepEvidence = null;
+  let stepEvidenceLoading = false;
+  let stepEvidenceError = "";
+  let fullEvidenceRequested = false;
+  let evidenceRevision = 0;
+  let chatActive = false;
+  let readRevision = 0;
+  let pendingWhileBusy = false;
+  let activeBackgroundReads = 0;
+
+  function resumePendingRefresh() {
+    if (!pendingWhileBusy || loading || stepEvidenceLoading) return;
+    pendingWhileBusy = false;
+    eventRefresh.schedule();
+  }
+
+  function render() {
+    const showing = chatActive && Boolean(runId);
+    dom.app.classList.toggle("automation-run-chat", showing);
+    dom.automationChatRunPanel.hidden = !showing;
+    dom.automationChatRunPanel.inert = !showing;
+    if (chatActive) {
+      dom.chatPanel.hidden = showing;
+      dom.chatPanel.inert = showing || dom.app.classList.contains("sessions-open");
+      const sessionsVisible = !showing &&
+        (dom.app.classList.contains("sessions-docked") || dom.app.classList.contains("sessions-open"));
+      dom.sessionsPanel.hidden = !sessionsVisible;
+      dom.sessionsPanel.inert = !sessionsVisible;
+      dom.sessionsToggleButton.hidden = showing || dom.app.classList.contains("sessions-docked");
+    }
+    if (!showing) {
+      liveView.clear();
+      return;
+    }
+    dom.automationChatRunPanel.setAttribute("aria-busy", String(loading));
+    liveView.update(runId, renderAutomationRun({
+      automations: [], selectedAutomationId: run?.automationId || "",
+      selectedRunId: runId, selectedNodeId, runs: [], run, error,
+      stepEvidence, stepEvidenceLoading, stepEvidenceError,
+      feedback: loading ? "Loading saved run…" : "",
+    }, { locked: true }));
+  }
+
+  function clear({ notify = true } = {}) {
+    if (!runId) return;
+    readRevision += 1;
+    runId = "";
+    run = null;
+    error = "";
+    loading = false;
+    selectedNodeId = "";
+    evidenceRevision += 1;
+    stepEvidence = null;
+    stepEvidenceLoading = false;
+    stepEvidenceError = "";
+    fullEvidenceRequested = false;
+    pendingWhileBusy = false;
+    eventRefresh.cancel();
+    render();
+    if (notify) onNavigationChange();
+  }
+
+  function matchesRead(selected, environmentId, revision) {
+    return revision === readRevision && selected === runId &&
+      environmentId === getEnvironmentId();
+  }
+
+  function matchesEvidence(selected, environmentId, revision, nodeId, evidenceRead) {
+    return matchesRead(selected, environmentId, revision) &&
+      nodeId === selectedNodeId && evidenceRead === evidenceRevision;
+  }
+
+  function loadInitialRun(loadedRun) {
+    run = loadedRun;
+    selectedNodeId = selectedAutomationRunStepId(run, selectedNodeId);
+    error = "";
+    loading = false;
+    if (selectedNodeId) return loadStepEvidence(run.id, selectedNodeId, fullEvidenceRequested);
+    render();
+    resumePendingRefresh();
+    return true;
+  }
+
+  async function reload({ background = false } = {}) {
+    if (!runId) return false;
+    const selected = runId;
+    const environmentId = getEnvironmentId();
+    const revision = ++readRevision;
+    const nodeId = selectedNodeId;
+    const full = fullEvidenceRequested;
+    const evidenceRead = ++evidenceRevision;
+    const isInitialRunRead = !run;
+    if (background) activeBackgroundReads += 1;
+    if (!background && !run) {
+      loading = true;
+      error = "";
+      render();
+    }
+    try {
+      const response = await client.getAutomationRun(selected, environmentId);
+      if (!matchesRead(selected, environmentId, revision)) return false;
+      if (!response?.run || response.run.id !== selected)
+        throw new Error("The selected automation run is unavailable.");
+      if (isInitialRunRead) return await loadInitialRun(response.run);
+      const evidenceNodeId = selectedAutomationRunStepId(response.run, nodeId);
+      let evidenceResponse = null;
+      if (evidenceNodeId) {
+        evidenceResponse = await client.getAutomationStepEvidence(
+          selected, evidenceNodeId, environmentId, full,
+        );
+      }
+      if (!matchesEvidence(selected, environmentId, revision, nodeId, evidenceRead)) return false;
+      if (evidenceNodeId && !hasSelectedStepEvidence(evidenceResponse, selected, evidenceNodeId))
+        throw new Error("The selected step evidence is unavailable.");
+      run = response.run;
+      selectedNodeId = evidenceNodeId;
+      stepEvidence = evidenceNodeId ? evidenceResponse.evidence : null;
+      stepEvidenceLoading = false;
+      stepEvidenceError = "";
+      error = "";
+      loading = false;
+      render();
+      resumePendingRefresh();
+      return true;
+    } catch (cause) {
+      if (!matchesEvidence(selected, environmentId, revision, nodeId, evidenceRead)) return false;
+      error = errorText(cause);
+      loading = false;
+      stepEvidenceLoading = false;
+      render();
+      resumePendingRefresh();
+      return false;
+    } finally {
+      if (background) activeBackgroundReads -= 1;
+    }
+  }
+
+  async function loadStepEvidence(selectedRunId, nodeId, full = false) {
+    const revision = ++evidenceRevision;
+    const read = readRevision;
+    const environmentId = getEnvironmentId();
+    if (activeBackgroundReads > 0) pendingWhileBusy = true;
+    if (stepEvidence?.runId !== selectedRunId || stepEvidence.nodeId !== nodeId)
+      stepEvidence = null;
+    stepEvidenceError = "";
+    stepEvidenceLoading = true;
+    render();
+    try {
+      const response = await client.getAutomationStepEvidence(selectedRunId, nodeId, environmentId, full);
+      if (!matchesEvidence(selectedRunId, environmentId, read, nodeId, revision)) return false;
+      if (!hasSelectedStepEvidence(response, selectedRunId, nodeId))
+        throw new Error("The selected step evidence is unavailable.");
+      stepEvidence = response.evidence;
+      return true;
+    } catch (cause) {
+      if (matchesEvidence(selectedRunId, environmentId, read, nodeId, revision))
+        stepEvidenceError = errorText(cause);
+      return false;
+    } finally {
+      if (matchesEvidence(selectedRunId, environmentId, read, nodeId, revision)) {
+        stepEvidenceLoading = false;
+        render();
+        resumePendingRefresh();
+      }
+    }
+  }
+
+  async function open(selected) {
+    if (!selected) { clear(); return true; }
+    if (selected !== runId) {
+      eventRefresh.cancel();
+      runId = selected;
+      run = null;
+      error = "";
+      loading = false;
+      selectedNodeId = "";
+      evidenceRevision += 1;
+      stepEvidence = null;
+      stepEvidenceLoading = false;
+      stepEvidenceError = "";
+      fullEvidenceRequested = false;
+      pendingWhileBusy = false;
+      liveView.clear();
+      onNavigationChange();
+    }
+    return reload();
+  }
+
+  async function stop() {
+    if (!run || !["pending", "running"].includes(run.status)) return;
+    const selected = runId;
+    const environmentId = getEnvironmentId();
+    try {
+      await client.stopAutomationRun(selected, environmentId);
+      if (selected === runId && environmentId === getEnvironmentId())
+        await reload({ background: true });
+    } catch (cause) {
+      if (selected !== runId || environmentId !== getEnvironmentId()) return;
+      error = errorText(cause);
+      render();
+    }
+  }
+
+  dom.automationChatRunPanel.addEventListener("click", (event) => {
+    const button = event.target.closest("button");
+    if (!button) return;
+    if (button.dataset.action === "stop") void stop();
+    if (button.dataset.action === "return-studio") returnToStudio(run);
+    if (button.dataset.action === "show-full-step-output" && selectedNodeId) {
+      fullEvidenceRequested = true;
+      void loadStepEvidence(runId, selectedNodeId, true);
+    }
+    if (button.dataset.automationNode !== undefined) {
+      selectedNodeId = button.dataset.automationNode;
+      evidenceRevision += 1;
+      stepEvidence = null;
+      stepEvidenceLoading = false;
+      stepEvidenceError = "";
+      fullEvidenceRequested = false;
+      if (selectedNodeId) void loadStepEvidence(runId, selectedNodeId);
+      else render();
+      focusSelectedAutomationStep(dom.automationChatRunPanel);
+    }
+  });
+  const eventRefresh = createEventRefresh({
+    canRefresh: () => chatActive && Boolean(runId) && isVisible(),
+    refresh: () => {
+      if (loading || stepEvidenceLoading) {
+        pendingWhileBusy = true;
+        return false;
+      }
+      return reload({ background: true });
+    },
+  });
+  render();
+  return {
+    open, clear, runId: () => runId,
+    workspaceChanged(workspace) {
+      chatActive = workspace === "chat";
+      if (!chatActive) clear({ notify: false });
+      render();
+    },
+    handleRealtime(message) {
+      if (isRunChange(message, getEnvironmentId(), runId)) eventRefresh.schedule();
+    },
+    reconnect: () => eventRefresh.schedule(),
+    visibilityChanged: () => eventRefresh.schedule(),
+  };
+}

package/dist/src/web-ui/app/components/automations/draft-recovery-actions.js

@@ -0,0 +1,28 @@
+import { escapeHtml } from "../../lib/text-format.js";
+import { renderAutomationEditorIcon } from "./editor-action-icons.js";
+
+export function renderAutomationDraftRecovery(snapshot) {
+  const undo = snapshot.draftUndo;
+  const undoTitle = undo ? `Undo the latest move of ${undo.title}. ${undo.count} saved move${undo.count === 1 ? "" : "s"} can be undone.`
+    : "Move a step to enable Undo. Move history is kept during this session.";
+  const published = snapshot.publishedDefinition;
+  const canRestore = published?.automationId === snapshot.selectedAutomationId &&
+    Number.isSafeInteger(published?.revision);
+  return `<button type="button" class="automation-editor-action" data-action="undo-draft-move" title="${escapeHtml(undoTitle)}"${!undo || snapshot.mutation ? " disabled" : ""}>${renderAutomationEditorIcon("undo")}<span>Undo move</span></button>
+    ${canRestore ? `<button type="button" class="automation-editor-action" data-action="restore-published-draft"${snapshot.mutation ? " disabled" : ""}>${renderAutomationEditorIcon("restore")}<span>Reset draft to published</span></button>` : ""}`;
+}
+
+export function createAutomationDraftRecoveryCommands({ actions, requireSavedGraph,
+  confirmDiscard, onRestored }) {
+  return {
+    "undo-draft-move": () => { if (requireSavedGraph()) return actions.undoDraftMove(); },
+    "restore-published-draft": async () => {
+      if (!requireSavedGraph()) return false;
+      const restored = await actions.restorePublishedDraft(({ title, publishedRevision }) => confirmDiscard(
+        `Replace the current draft of “${title}” with published revision ${publishedRevision}? Unpublished draft changes will be discarded. The published version, schedule, permissions, and existing runs will stay unchanged.`,
+      ));
+      if (restored) onRestored();
+      return restored;
+    },
+  };
+}

package/dist/src/web-ui/app/components/automations/editor-action-icons.js

@@ -0,0 +1,18 @@
+const EDITOR_ACTION_ICONS = {
+  save: '<path d="M19 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h12l4 4v12a2 2 0 0 1-2 2Z"/><path d="M7 3v6h10V3M7 21v-8h10v8"/>',
+  build: '<path d="m12 3 2.5 6.5L21 12l-6.5 2.5L12 21l-2.5-6.5L3 12l6.5-2.5L12 3Z"/>',
+  check: '<circle cx="12" cy="12" r="9"/><path d="m8 12 3 3 5-6"/>',
+  publish: '<path d="M12 16V3m-5 5 5-5 5 5M4 15v5h16v-5"/>',
+  run: '<path d="m8 4 12 8-12 8V4Z"/>',
+  activate: '<path d="M12 2v10M6 5a9 9 0 1 0 12 0"/>',
+  pause: '<rect x="6" y="4" width="4" height="16" rx="1"/><rect x="14" y="4" width="4" height="16" rx="1"/>',
+  archive: '<rect x="3" y="3" width="18" height="4" rx="1"/><path d="M5 7v14h14V7M9 11h6"/>',
+  restore: '<path d="M3 11a9 9 0 1 1 2.6 7.4M3 4v7h7"/>',
+  undo: '<path d="m9 4-6 6 6 6M3 10h11a7 7 0 0 1 7 7v3"/>',
+  delete: '<path d="M3 6h18M9 6V3h6v3M5 6l1 15h12l1-15M10 10v7m4-7v7"/>',
+  manage: '<path d="M4 7h16M4 17h16"/><circle cx="9" cy="7" r="2"/><circle cx="15" cy="17" r="2"/>',
+};
+
+export function renderAutomationEditorIcon(name) {
+  return `<svg class="automation-editor-action-icon" viewBox="0 0 24 24" aria-hidden="true" focusable="false" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round">${EDITOR_ACTION_ICONS[name] || ""}</svg>`;
+}

package/dist/src/web-ui/app/components/automations/editor-actions.js

@@ -0,0 +1,57 @@
+import { escapeHtml } from "../../lib/text-format.js";
+import { renderAutomationDraftRecovery } from "./draft-recovery-actions.js";
+import { renderAutomationEditorIcon } from "./editor-action-icons.js";
+
+function editorAction(action, label, icon, { className = "", disabled = false, busy = false, title = "" } = {}) {
+  return `<button type="button" class="automation-editor-action ${className}" data-action="${action}"${disabled ? " disabled" : ""}${busy ? ' aria-busy="true"' : ""}${title ? ` title="${escapeHtml(title)}"` : ""}>${renderAutomationEditorIcon(icon)}<span>${label}</span></button>`;
+}
+
+function renderDraftActions() {
+  return `<div class="automation-editor-action-group" role="group" aria-label="Draft actions">
+    <span class="automation-editor-action-label">Draft</span><div class="automation-actions">
+      ${editorAction("save-draft", "Save draft", "save", { title: "Save automation settings to the draft" })}
+      ${editorAction("describe", "Build with ABot", "build")}
+      ${editorAction("validate", "Check", "check", { title: "Check the draft before publishing" })}
+      ${editorAction("publish", "Publish", "publish", { className: "automation-primary", title: "Publish this draft for future runs" })}
+    </div></div>`;
+}
+
+function renderExecutionActions(snapshot, current, runUnavailable, activateUnavailable) {
+  const active = current.status === "active";
+  const runPending = Boolean(snapshot.runStartPending);
+  const runActionDisabled = runUnavailable || runPending || snapshot.loading || Boolean(snapshot.mutation);
+  return `<div class="automation-editor-action-group automation-editor-execution" role="group" aria-label="Execution actions">
+    <span class="automation-editor-action-label">Execution <span class="automation-editor-state" data-state="${active ? "active" : "paused"}">${active ? "Active" : "Paused"}</span></span>
+    <div class="automation-actions">
+      ${editorAction("run", runPending ? "Starting…" : "Run now", "run", { disabled: runActionDisabled, busy: runPending,
+        title: runUnavailable ? current.runUnavailableReason || "Run unavailable" : "Run the published version once" })}
+      ${editorAction("toggle-active", active ? "Pause" : "Activate", active ? "pause" : "activate", {
+        className: active ? "automation-editor-pause" : "automation-editor-activate", disabled: activateUnavailable,
+        title: activateUnavailable ? current.activateUnavailableReason || "Activation unavailable"
+          : active ? "Pause automatic triggers" : "Enable automatic triggers for the published version" })}
+    </div></div>`;
+}
+
+function renderManagementActions(snapshot, published, canDeleteDraft) {
+  const archive = published ? editorAction("archive", "Archive automation", "archive", { className: "automation-editor-archive" })
+    : canDeleteDraft ? editorAction("delete-draft", "Delete draft", "delete", { className: "automation-stop" }) : "";
+  return `<details class="automation-editor-management"><summary>${renderAutomationEditorIcon("manage")}<span>Manage automation</span></summary>
+    <div class="automation-editor-management-body">
+      <div class="automation-editor-action-group" role="group" aria-label="Draft recovery">
+        <span class="automation-editor-action-label">Draft recovery</span><div class="automation-actions">${renderAutomationDraftRecovery(snapshot)}</div>
+      </div>
+      ${archive ? `<div class="automation-editor-archive-group"><span class="automation-editor-action-label">${published ? "Archive" : "Delete draft"}</span><div class="automation-actions">${archive}</div>
+        <p>${published ? "Pause its schedule and move it to the archive. Runs and reports stay available." : "Permanently remove this unpublished draft."}</p></div>` : ""}
+    </div></details>`;
+}
+
+export function renderAutomationEditorActions(snapshot, { current, canDeleteDraft, runUnavailable, activateUnavailable }) {
+  if (current?.status === "archived") {
+    return `<div class="automation-editor-actionbar automation-actions">${editorAction("restore", "Restore automation", "restore", { className: "automation-primary" })}</div>`;
+  }
+  const published = Boolean(current?.publishedRevision);
+  return `<div class="automation-editor-actionbar" aria-label="Automation actions">
+    <div class="automation-editor-action-groups">${renderDraftActions()}${published ? renderExecutionActions(snapshot, current, runUnavailable, activateUnavailable) : ""}</div>
+    ${renderManagementActions(snapshot, published, canDeleteDraft)}
+  </div>`;
+}

package/dist/src/web-ui/app/components/automations/editor.js

@@ -0,0 +1,218 @@
+import { escapeHtml } from "../../lib/text-format.js";
+import { findAutomationNode, renderAutomationTimeline } from "./timeline.js";
+import { operationIdentity } from "./node-inspector.js";
+import { renderAutomationStepPreview } from "./step-preview.js";
+import { renderAutomationEditorActions } from "./editor-actions.js";
+import { toolDisplayName } from "./tool-identity.js";
+export { toolDisplayName } from "./tool-identity.js";
+import { listAvailableAutomationProducers } from "../../lib/automation-binding-producers.js";
+import { requiresFullPlus, selectedAutomationOperations } from "./permission-selection.js";
+
+function triggerChoice(trigger) {
+  return trigger?.kind === "schedule" ? trigger.schedule?.kind || "daily" : trigger?.kind || "manual";
+}
+
+function renderTriggerFields(definition) {
+  const selected = triggerChoice(definition.trigger);
+  const schedule = definition.trigger?.schedule || {};
+  return `<div class="automation-trigger-fields"><label>Start<select name="triggerKind">
+    ${[["manual","Manual"],["folder","New files"],["timer","After delay"],["once","Once"],["interval","Interval"],["daily","Daily"],["weekly","Weekly"],["monthly","Monthly"]].map(([kind,label]) => `<option value="${kind}"${selected === kind ? " selected" : ""}>${label}</option>`).join("")}</select></label>
+    <label>Time or minutes<input name="triggerValue" value="${escapeHtml(selected === "interval" ? Math.round((schedule.everyMs || 3_600_000) / 60_000) : selected === "timer" ? Math.round((schedule.delayMs || 60_000) / 60_000) : selected === "once" ? schedule.at || "" : schedule.at || "09:00")}" placeholder="09:00 or minutes"></label>
+    <label>Weekdays (0–6)<input name="weekdays" value="${escapeHtml((schedule.weekdays || []).join(","))}" placeholder="1,2,3,4,5"></label>
+    <label>Day of month<input name="dayOfMonth" type="number" min="1" max="31" value="${escapeHtml(schedule.dayOfMonth || 1)}"></label>
+    <label>Minimum new files<input name="minimumEligibleFiles" type="number" min="1" value="${escapeHtml(definition.trigger?.minimumEligibleFiles || 1)}"></label>
+    <label>Check every (minutes)<input name="checkEveryMinutes" type="number" min="1" value="${escapeHtml(Math.round((definition.trigger?.checkEveryMs || 300_000) / 60_000))}"></label>
+  </div>`;
+}
+
+function renderSourceFields(source) {
+  return `<details class="automation-source"${source ? " open" : ""}><summary>Folder source · optional</summary>
+    <div class="automation-source-options">
+      <label><input type="checkbox" name="sourceEnabled"${source ? " checked" : ""}>Use a folder</label>
+      <label><input type="checkbox" name="sourceRecursive"${source?.recursive ? " checked" : ""}>Include subfolders</label>
+      <label><input type="checkbox" name="includeExisting"${source?.includeExisting ? " checked" : ""}>Include files already there on first activation</label>
+    </div><div class="automation-source-fields"><label>Runtime-visible folder<input name="sourcePath" value="${escapeHtml(source?.location?.path || "")}" placeholder="/workspace/inbox"></label>
+      <label>Process<select name="sourceMode"><option value="per_file"${source?.mode !== "batch" ? " selected" : ""}>Each file</option><option value="batch"${source?.mode === "batch" ? " selected" : ""}>Batch</option></select></label>
+      <label>Max files per batch<input type="number" name="maxBatchFiles" min="1" max="100" value="${escapeHtml(source?.maxBatchFiles || 100)}"></label>
+      <label>Include patterns<input name="includePatterns" value="${escapeHtml((source?.includePatterns || []).join(", "))}" placeholder="*.pdf, *.txt"></label>
+      <label>Exclude outputs and archive paths<input name="excludePatterns" value="${escapeHtml((source?.excludePatterns || []).join(", "))}" placeholder="archive/**, output/**"></label>
+    </div><p class="automation-muted">The Runtime must be able to read this folder. If a step writes or archives files, exclude those destinations so they cannot become new inputs. Publishing never starts processing existing files by itself.</p>
+  </details>`;
+}
+
+function renderLimits(limits) {
+  if (!limits) return "";
+  return `<details class="automation-limits"><summary>Resource limits</summary><div class="automation-limit-fields">
+    ${[["maxModelCallsPerRun","Model calls / run"],["maxToolCallsPerRun","Tool calls / run"],["maxConcurrentNodes","Parallel steps"],["maxRunsPerDay","Runs / day"],["maxRunDurationMs","Run duration (ms)"],["maxStoredArtifactBytes","Stored artifacts (bytes)"],["stopReportDeadlineMs","Stop report deadline (ms)"]].map(([key,label]) => `<label>${label}<input type="number" min="1" name="limit-${key}" value="${escapeHtml(limits[key])}"${key === "maxModelCallsPerRun" ? ` aria-describedby="automation-model-limit-help"` : ""}></label>`).join("")}
+  </div><p class="automation-muted" id="automation-model-limit-help">Model calls include decisions, tool discovery, input preparation and final responses across the whole run. This limit is a ceiling, not the desired number of calls. Usage varies by model and workflow; use completed-run usage in Execution details to choose headroom. Tool calls count admitted attempts, including failed attempts.</p>
+  <p class="automation-muted">Save the draft and publish to apply changed limits to future runs. An existing run keeps its published limits.</p></details>`;
+}
+
+function toolCatalogItems(catalog) {
+  const operations = Array.isArray(catalog?.grantableOperations)
+    ? catalog.grantableOperations : catalog?.operations || [];
+  const tools = new Map();
+  for (const operation of operations) {
+    const existing = tools.get(operation.toolName) || {
+      name: operation.toolName,
+      label: toolDisplayName(operation.toolName),
+      group: operation.pluginName || "Built-in",
+      description: operation.toolDescription || "",
+      operations: [],
+    };
+    existing.operations.push(operation);
+    tools.set(operation.toolName, existing);
+  }
+  return [...tools.values()].sort((left, right) =>
+    left.group.localeCompare(right.group) || left.label.localeCompare(right.label));
+}
+
+export function renderAutomationToolResults(catalog, { query = "", selectedToolName = "" } = {}) {
+  const normalized = query.trim().toLocaleLowerCase();
+  const tools = toolCatalogItems(catalog).filter((tool) => !normalized ||
+    [tool.label, tool.name, tool.group, tool.description,
+      ...tool.operations.map((operation) => `${operation.operationId} ${operation.label || ""}`)]
+      .some((value) => value.toLocaleLowerCase().includes(normalized)));
+  if (!tools.length) return `<p class="automation-muted">${normalized ? "No matching tools." : "No tools are configured yet. You can still build with agents."}</p>`;
+  const granted = new Set((catalog?.operations || []).map((item) =>
+    operationIdentity(item)));
+  const groups = new Map();
+  for (const tool of tools) {
+    if (!groups.has(tool.group)) groups.set(tool.group, []);
+    groups.get(tool.group).push(tool);
+  }
+  return [...groups.entries()].map(([group, entries]) => {
+    const expanded = Boolean(normalized || entries.some((tool) => tool.name === selectedToolName));
+    const operationCount = entries.reduce((count, tool) => count + tool.operations.length, 0);
+    return `<details class="automation-tool-group"${expanded ? " open" : ""}><summary><strong>${escapeHtml(toolDisplayName(group))}</strong><small>${entries.length} ${entries.length === 1 ? "tool" : "tools"} · ${operationCount} ${operationCount === 1 ? "operation" : "operations"}</small></summary><div class="automation-plugin-tools">${entries.map((tool) => {
+    const selected = tool.name === selectedToolName;
+    return `<div class="automation-tool-choice"><button type="button" draggable="true" class="automation-palette-item" data-palette-select-tool="${escapeHtml(tool.name)}" data-palette-tool="${escapeHtml(tool.name)}" aria-expanded="${selected}">${escapeHtml(tool.label)}<small>${escapeHtml(tool.operations.length)} ${tool.operations.length === 1 ? "operation" : "operations"}</small></button>
+      ${selected ? `<div class="automation-tool-operations"><p>Choose the operation and inputs after adding this tool.</p>${tool.operations.map((operation) => {
+        const identity = operationIdentity(operation);
+        const allowed = granted.has(identity);
+        return `<div class="automation-tool-operation"><strong>${escapeHtml(toolDisplayName(operation.operationId))}</strong><span>${requiresFullPlus(operation) ? "FULL+" : "Full"}${allowed ? "" : " · permission needed"}</span><small>${escapeHtml(operation.label || "")}</small></div>`;
+      }).join("")}<button type="button" class="automation-tool-add" data-palette-add-tool="${escapeHtml(tool.name)}">Add to timeline</button></div>` : ""}</div>`;
+  }).join("")}</div></details>`;
+  }).join("");
+}
+
+function paletteAgent(item) {
+  return `<button type="button" draggable="true" class="automation-palette-item automation-agent-choice" data-palette-agent="${escapeHtml(item.agentId || item.id)}"><strong dir="auto">${escapeHtml(item.agent?.title || item.title || "Saved agent")}</strong><small>Saved agent · revision ${escapeHtml(item.revision || 1)}</small></button>`;
+}
+
+function renderValidation(validation) {
+  const issues = Array.isArray(validation?.issues) ? validation.issues : [];
+  if (!issues.length) return "";
+  return `<div class="automation-validation" role="alert"><strong>Needs attention before publishing</strong>${issues.map((issue) => `<button type="button" data-select-node="${escapeHtml(issue.nodeId || "")}"><code>${escapeHtml(issue.code || "automation_graph_invalid")}</code>${issue.path ? ` · <code>${escapeHtml(issue.path)}</code>` : ""} · ${escapeHtml(issue.message || "Check this step")}</button>`).join("")}</div>`;
+}
+
+function renderToolPermissionRequirements(selection) {
+  let requirement = "";
+  if (selection.operations.length) {
+    const operations = selection.details.map((operation) => `<li><span>${escapeHtml(toolDisplayName(operation.toolName))} · ${escapeHtml(toolDisplayName(operation.operationId))}</span><strong>${requiresFullPlus(operation) ? "FULL+" : "Full"}</strong></li>`).join("");
+    requirement = `<ul class="automation-permission-list">${operations}</ul>`;
+  } else if (!selection.missing.length) {
+    requirement = `<p>No tool operations selected.</p>`;
+  }
+  const count = selection.operations.length;
+  const state = `${selectedToolPermissionLabel(selection)}${count ? ` · ${count} selected operation${count === 1 ? "" : "s"}` : ""}${selection.missing.length ? ` · ${selection.missing.length} unavailable` : ""}`;
+  return `<details class="automation-permission"><summary>Tool permission <span class="automation-permission-state">${escapeHtml(state)}</span></summary>
+    ${requirement}
+    ${selection.missing.length ? `<p>${selection.missing.length} selected operation${selection.missing.length === 1 ? " is" : "s are"} unavailable in the current tool catalog.</p>` : ""}
+  </details>`;
+}
+
+function selectedToolPermissionLabel(selection) {
+  if (!selection.operations.length && selection.missing.length) return "Selected tool unavailable";
+  if (!selection.operations.length) return "No tools selected";
+  return selection.mode === "full_plus" ? "FULL+ required" : "Full required";
+}
+
+export function renderAutomationEditor(snapshot, paletteState = {}) {
+  const definition = snapshot.draft?.definition;
+  if (!definition) return `<p class="automation-feedback" role="status">${escapeHtml(snapshot.error || "Loading draft…")}</p>`;
+  const selected = findAutomationNode(definition.body, snapshot.selectedNodeId);
+  const producers = listAvailableAutomationProducers(definition.body, snapshot.selectedNodeId);
+  const catalog = snapshot.catalog || { operations: [], models: [], savedAgents: [] };
+  const current = snapshot.automations.find((item) => item.id === snapshot.selectedAutomationId);
+  const published = Boolean(current?.publishedRevision);
+  const archived = current?.status === "archived" || Boolean(snapshot.draft?.archivedAt);
+  const runUnavailable = published && current?.canRun === false;
+  const activateUnavailable = published && current?.status !== "active" && current?.canActivate === false;
+  const selectedOperations = selectedAutomationOperations(definition, catalog);
+  const permission = selectedToolPermissionLabel(selectedOperations);
+  const inspectorMarkup = !archived ? renderAutomationStepPreview(selected, catalog, producers) : "";
+  return `<div class="automation-workspace" data-automation-view="editor">
+    <section class="automation-definition-panel" aria-label="Automation details">
+    <div class="automation-heading"><div><button type="button" class="automation-text-button" data-action="back">← All automations</button><h3 dir="auto">${escapeHtml(definition.title || "ABot Automation")}</h3><p>Draft revision ${escapeHtml(snapshot.draft.revision)}${published ? ` · Published revision ${escapeHtml(current.publishedRevision)}` : " · Not published"}${archived ? " · Archived" : ""}</p></div>
+      <div class="automation-heading-actions"><button type="button" class="automation-details-toggle" data-action="toggle-details" aria-controls="automation-editor-details" aria-expanded="true"><span data-details-label>Collapse details</span></button></div></div>
+    ${renderAutomationEditorActions(snapshot, { current: archived ? { ...current, status: "archived" } : current, canDeleteDraft: current && !snapshot.publishedDefinition, runUnavailable, activateUnavailable })}
+    ${!archived && (runUnavailable || activateUnavailable) ? `<p class="automation-action-note" role="status">${escapeHtml(current.runUnavailableReason || current.activateUnavailableReason || "This automation cannot start yet.")}</p>` : ""}
+    <p class="automation-feedback" role="status" aria-live="polite" data-tone="${snapshot.error ? "error" : ""}">${escapeHtml(snapshot.error || snapshot.feedback || (archived ? "Archived. Restore to edit or run it. Reports remain available." : "Step and order changes are saved to the draft immediately. Automation settings use Save draft. Publishing is separate."))}</p>
+    <div class="automation-editor-details" id="automation-editor-details">
+    <div class="automation-tabs" role="tablist"><button type="button" role="tab" aria-selected="true">Editor</button><button type="button" role="tab" aria-selected="false" data-action="show-runs">Runs (${escapeHtml(snapshot.runs.length)})</button></div>
+    <div class="automation-summary"><span><strong>Start</strong> · ${escapeHtml(triggerChoice(definition.trigger))}</span><span><strong>Permission</strong> · ${permission}</span><span><strong>Model</strong> · Per agent</span></div>
+    ${renderValidation(!archived && snapshot.validationVisible ? snapshot.validation : null)}
+    <form class="automation-definition-form" data-automation-definition-form${archived ? " inert" : ""}><div class="automation-top-fields"><label>Name<input name="title" value="${escapeHtml(definition.title || "")}" required dir="auto"></label><label>Goal<textarea name="objective" dir="auto">${escapeHtml(definition.objective || "")}</textarea></label></div>
+      <label>Working directory<input name="workingDirectory" value="${escapeHtml(definition.workingDirectory || "")}" placeholder="Optional absolute path on the Runtime host"></label>
+      <details class="automation-run-inputs"><summary>Run inputs · JSON object</summary><label>Values supplied when a run starts<textarea name="inputsJson" spellcheck="false">${escapeHtml(JSON.stringify(definition.inputs || {}, null, 2))}</textarea></label></details>
+      ${renderTriggerFields(definition)}${renderSourceFields(definition.source)}${renderLimits(definition.limits)}
+      ${renderToolPermissionRequirements(selectedOperations)}
+    </form>
+    </div>
+    </section>
+    ${archived ? `<section class="automation-canvas automation-archived-canvas" aria-label="Workflow">${renderAutomationTimeline(definition, { editable: false, catalog })}</section>` : `<div class="automation-editor-layout"><div class="automation-editor-sidebar"><section class="automation-palette" aria-label="Agents"><h4>Agents</h4><p>Add a new agent or reuse one you saved.</p>
+        <button type="button" draggable="true" class="automation-palette-item automation-agent-choice" data-palette-agent="new"><strong>New agent</strong><small>Set model, role, and prompt</small></button>
+        ${(catalog.savedAgents || []).map(paletteAgent).join("")}
+      </section><section class="automation-palette" aria-label="Tools"><h4>Tools</h4><p>Open a plugin to choose a tool.</p>
+      <label class="automation-tool-search">Search plugins, tools, or operations<input type="search" data-tool-search value="${escapeHtml(paletteState.query || "")}" placeholder="Search plugins or tools" autocomplete="off"></label>
+      <div data-automation-tool-results>${renderAutomationToolResults(catalog, paletteState)}</div>
+      <button type="button" data-action="move-to-slot" hidden>Move selected step here</button></section>
+      </div><section class="automation-canvas" aria-label="Workflow">${renderAutomationTimeline(definition, { editable: true, selectedNodeId: snapshot.selectedNodeId, inspectorMarkup, catalog })}</section></div>`}
+  </div>`;
+}
+
+function commaValues(value) {
+  return value.split(",").map((item) => item.trim()).filter(Boolean);
+}
+
+function readTrigger(fields) {
+  const kind = String(fields.get("triggerKind") || "manual");
+  if (kind === "manual") return { kind };
+  if (kind === "folder") return {
+    kind, checkEveryMs: Number(fields.get("checkEveryMinutes")) * 60_000,
+    minimumEligibleFiles: Number(fields.get("minimumEligibleFiles")),
+  };
+  const value = String(fields.get("triggerValue") || "").trim();
+  if (kind === "timer") return { kind: "schedule", schedule: { kind, delayMs: Number(value) * 60_000 } };
+  if (kind === "interval") return { kind: "schedule", schedule: { kind, everyMs: Number(value) * 60_000 } };
+  if (kind === "weekly") return { kind: "schedule", schedule: { kind, at: value, weekdays: commaValues(String(fields.get("weekdays") || "")).map(Number) } };
+  if (kind === "monthly") return { kind: "schedule", schedule: { kind, at: value, dayOfMonth: Number(fields.get("dayOfMonth")) } };
+  return { kind: "schedule", schedule: { kind, at: value } };
+}
+
+export function readAutomationDefinitionPatch(form, definition) {
+  const fields = new FormData(form);
+  let inputs;
+  try { inputs = JSON.parse(String(fields.get("inputsJson") || "{}")); }
+  catch { throw new Error("Run inputs must be valid JSON."); }
+  if (!inputs || typeof inputs !== "object" || Array.isArray(inputs))
+    throw new Error("Run inputs must be a JSON object.");
+  const sourceEnabled = fields.has("sourceEnabled");
+  const source = sourceEnabled ? {
+    sourceId: definition.source?.sourceId || "",
+    location: { kind: "runtime_path", path: String(fields.get("sourcePath") || "").trim() },
+    includePatterns: commaValues(String(fields.get("includePatterns") || "")),
+    excludePatterns: commaValues(String(fields.get("excludePatterns") || "")),
+    recursive: fields.has("sourceRecursive"), includeExisting: fields.has("includeExisting"),
+    mode: fields.get("sourceMode") === "batch" ? "batch" : "per_file",
+    maxBatchFiles: Number(fields.get("maxBatchFiles")),
+  } : null;
+  const limits = { ...definition.limits };
+  for (const key of Object.keys(limits)) limits[key] = Number(fields.get(`limit-${key}`));
+  return {
+    title: String(fields.get("title") || "").trim(), objective: String(fields.get("objective") || "").trim(),
+    workingDirectory: String(fields.get("workingDirectory") || "").trim() || null,
+    trigger: readTrigger(fields), source, inputs, limits,
+  };
+}