@agent-native/core 0.136.3 → 0.136.4

package/dist/server/agent-chat-plugin.js

@@ -420,6 +420,7 @@ export function createAgentChatPlugin(options) {
                 ...loopSettingsScripts,
             };
             const callAgentScript = await createCallAgentScriptEntry(options?.appId);
+            let runNowSchedulerDeps = null;
             const browserTools = createBuilderBrowserTool({
                 getOrigin: () => getRequestRunContext()?.requestOrigin ?? "http://localhost:3000",
                 getOwner: () => getRequestRunContext()?.owner ?? getRequestUserEmail(),
@@ -741,15 +742,18 @@ export function createAgentChatPlugin(options) {
                 });
             }
             catch { }
-            // Core send-email tool — only registered when RESEND_API_KEY or
-            // SENDGRID_API_KEY is set. Keyed "core-send-email" to avoid colliding
+            // Core send-email tool. Keyed "core-send-email" to avoid colliding
             // with the mail template's richer "send-email" action (template wins
             // when both surfaces spread into the same object, but distinct keys
             // keep both visible and avoid silent shadowing).
             let coreEmailTools = {};
+            let backgroundCoreEmailTools = {};
             try {
                 const { createCoreEmailActionEntries } = await import("./email-actions.js");
                 coreEmailTools = createCoreEmailActionEntries();
+                backgroundCoreEmailTools = createCoreEmailActionEntries({
+                    unattended: true,
+                });
             }
             catch { }
             // Core read-attachment tool — always registered so the agent can page
@@ -760,6 +764,29 @@ export function createAgentChatPlugin(options) {
                 coreAttachmentTools = createCoreAttachmentActionEntries();
             }
             catch { }
+            // Keep scheduler and event-trigger runs on one deliberately bounded
+            // background surface. Interactive-only tools stay out of it, while
+            // shared capabilities such as call-agent and core-send-email cannot
+            // drift independently between the two background entry points.
+            const getBackgroundActionEntries = (automation) => ({
+                ...templateScripts,
+                ...resourceScripts,
+                ...docsScripts,
+                ...(lazyContext ? frameworkContextTool : {}),
+                ...urlTools,
+                ...chatScripts,
+                ...callAgentScript,
+                ...jobTools,
+                ...automationTools,
+                ...notificationTools,
+                ...progressTools,
+                ...fetchTool,
+                ...webSearchTool,
+                ...toolActions,
+                ...backgroundCoreEmailTools,
+                ...coreAttachmentTools,
+                ...getJobMcpActionEntries(automation),
+            });
             // -----------------------------------------------------------------------
             // Production code-execution mode resolution.
             //
@@ -4432,6 +4459,50 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                     return { error: prepared.error };
                 }
                 const preparedMarker = prepared.body[AGENT_CHAT_BACKGROUND_RUN_FIELD];
+                const automationRunId = preparedMarker && typeof preparedMarker === "object"
+                    ? preparedMarker.automationRunId
+                    : undefined;
+                if (typeof automationRunId === "string" && automationRunId) {
+                    const runAutomation = async () => {
+                        try {
+                            if (!runNowSchedulerDeps) {
+                                throw new Error("Automation runner is not initialized.");
+                            }
+                            const { runQueuedAutomation } = await import("../jobs/scheduler.js");
+                            const result = await runQueuedAutomation(automationRunId, runNowSchedulerDeps);
+                            return { ok: true, automationRunId, ...result };
+                        }
+                        catch (error) {
+                            const message = error instanceof Error ? error.message : String(error);
+                            const { finishAutomationRun } = await import("../jobs/run-history.js");
+                            await finishAutomationRun(automationRunId, "error", `Automation worker failed: ${message}. No delivery was confirmed.`).catch((finishError) => {
+                                console.warn(`[automations] could not record run-now worker failure for ${automationRunId}:`, finishError);
+                            });
+                            console.error(`[automations] run-now worker failed for ${automationRunId}:`, error);
+                            throw error;
+                        }
+                    };
+                    // Netlify background functions must keep the handler open for the
+                    // full automation. Other runtimes get an immediate receipt and
+                    // use waitUntil when the platform provides it; long-lived Node
+                    // processes can safely continue the promise after the response.
+                    if (isInBackgroundFunctionRuntime()) {
+                        try {
+                            return await runAutomation();
+                        }
+                        catch {
+                            setResponseStatus(event, 500);
+                            return { error: "Automation worker failed" };
+                        }
+                    }
+                    const waitUntil = event.req?.waitUntil;
+                    const runPromise = runAutomation().catch(() => { });
+                    if (typeof waitUntil === "function") {
+                        waitUntil(runPromise);
+                    }
+                    setResponseStatus(event, 202);
+                    return { ok: true, accepted: true, automationRunId };
+                }
                 const expectsBackgroundRuntime = backgroundRunMarkerExpectsBackgroundRuntime(preparedMarker);
                 const runtimeGlobals = globalThis;
                 const hadExpectedRuntimeMarker = Object.prototype.hasOwnProperty.call(runtimeGlobals, "__AGENT_NATIVE_BACKGROUND_RUNTIME_EXPECTED__");
@@ -4582,55 +4653,42 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
             // Poll every 60 seconds for due recurring jobs and execute them.
             // Uses setInterval so it works in all deployment environments without
             // requiring Nitro experimental tasks configuration.
-            if (disableRecurringJobsRuntime) {
-                if (process.env.DEBUG) {
-                    console.log("[recurring-jobs] Scheduler disabled for local development");
+            try {
+                const { processRecurringJobs } = await import("../jobs/scheduler.js");
+                const schedulerDeps = {
+                    getActions: getBackgroundActionEntries,
+                    getSystemPrompt: async (owner) => {
+                        const resources = await loadResourcesForPrompt(owner, lazyContext, options?.appId);
+                        const schemaBlock = lazyContext
+                            ? ""
+                            : await buildSchemaBlock(owner, databaseToolsMode);
+                        return basePrompt + resources + schemaBlock;
+                    },
+                    // `basePrompt` above is the same prompt the interactive chat
+                    // handler builds, so it teaches the same template actions plus
+                    // `manage-jobs` (Extended Capabilities / recurring jobs) and
+                    // `manage-progress` (SHARED_RULE_14) BY NAME — both are present in
+                    // getActions() via jobTools/progressTools. Keep the job runner's
+                    // first request on the same compact surface as interactive chat
+                    // instead of the full jobTools/automationTools/notificationTools/
+                    // fetchTool/webSearchTool/toolActions catalog every tick.
+                    getInitialToolNames: (job) => [
+                        ...effectiveInitialToolNames,
+                        "manage-jobs",
+                        "manage-progress",
+                        ...(job?.meta.mcpTools ?? []),
+                    ],
+                    apiKey: options?.apiKey,
+                    model: options?.model,
+                    appId: options?.appId,
+                };
+                runNowSchedulerDeps = schedulerDeps;
+                if (disableRecurringJobsRuntime) {
+                    if (process.env.DEBUG) {
+                        console.log("[recurring-jobs] Scheduler disabled for local development");
+                    }
                 }
-            }
-            else {
-                try {
-                    const { processRecurringJobs } = await import("../jobs/scheduler.js");
-                    const schedulerDeps = {
-                        getActions: (job) => ({
-                            ...templateScripts,
-                            ...resourceScripts,
-                            ...docsScripts,
-                            ...(lazyContext ? frameworkContextTool : {}),
-                            ...chatScripts,
-                            ...jobTools,
-                            ...automationTools,
-                            ...notificationTools,
-                            ...progressTools,
-                            ...fetchTool,
-                            ...webSearchTool,
-                            ...toolActions,
-                            ...getJobMcpActionEntries(job),
-                        }),
-                        getSystemPrompt: async (owner) => {
-                            const resources = await loadResourcesForPrompt(owner, lazyContext, options?.appId);
-                            const schemaBlock = lazyContext
-                                ? ""
-                                : await buildSchemaBlock(owner, databaseToolsMode);
-                            return basePrompt + resources + schemaBlock;
-                        },
-                        // `basePrompt` above is the same prompt the interactive chat
-                        // handler builds, so it teaches the same template actions plus
-                        // `manage-jobs` (Extended Capabilities / recurring jobs) and
-                        // `manage-progress` (SHARED_RULE_14) BY NAME — both are present in
-                        // getActions() via jobTools/progressTools. Keep the job runner's
-                        // first request on the same compact surface as interactive chat
-                        // instead of the full jobTools/automationTools/notificationTools/
-                        // fetchTool/webSearchTool/toolActions catalog every tick.
-                        getInitialToolNames: (job) => [
-                            ...effectiveInitialToolNames,
-                            "manage-jobs",
-                            "manage-progress",
-                            ...(job?.meta.mcpTools ?? []),
-                        ],
-                        apiKey: options?.apiKey,
-                        model: options?.model,
-                        appId: options?.appId,
-                    };
+                else {
                     // Start after a 10-second delay to let the server fully initialize
                     setTimeout(() => {
                         setInterval(() => {
@@ -4642,10 +4700,33 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                             console.log("[recurring-jobs] Scheduler started (60s interval)");
                     }, 10_000);
                 }
-                catch (err) {
-                    // Jobs module not available — skip silently
-                }
             }
+            catch (error) {
+                console.warn("[recurring-jobs] Scheduler module unavailable:", error instanceof Error ? error.message : error);
+            }
+            // A non-Netlify self-dispatch only waits for the request to leave the
+            // current invocation. Keep the durable history row as a retryable queue
+            // so a frozen serverless handoff is recovered on the next sweep.
+            (() => {
+                let inFlight = false;
+                const sweep = async () => {
+                    if (inFlight)
+                        return;
+                    inFlight = true;
+                    try {
+                        const { redispatchUnclaimedAutomationRuns } = await import("../jobs/run-now.js");
+                        await redispatchUnclaimedAutomationRuns();
+                    }
+                    catch (error) {
+                        console.warn("[automations] queued-run sweep failed; retrying next tick:", error);
+                    }
+                    finally {
+                        inFlight = false;
+                    }
+                };
+                setTimeout(() => void sweep(), 15_000);
+                setInterval(() => void sweep(), 30_000);
+            })();
             mcpInitializationPromise = initializeMcpManager().catch((err) => {
                 console.warn(`[mcp-client] deferred initialization failed: ${err?.message ?? err}`);
             });
@@ -4912,21 +4993,7 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                 try {
                     const { initTriggerDispatcher } = await import("../triggers/dispatcher.js");
                     await initTriggerDispatcher({
-                        getActions: (automation) => ({
-                            ...templateScripts,
-                            ...resourceScripts,
-                            ...docsScripts,
-                            ...(lazyContext ? frameworkContextTool : {}),
-                            ...chatScripts,
-                            ...jobTools,
-                            ...automationTools,
-                            ...notificationTools,
-                            ...progressTools,
-                            ...fetchTool,
-                            ...webSearchTool,
-                            ...toolActions,
-                            ...getJobMcpActionEntries(automation),
-                        }),
+                        getActions: getBackgroundActionEntries,
                         getSystemPrompt: async (owner) => {
                             const resources = await loadResourcesForPrompt(owner, lazyContext, options?.appId);
                             const schemaBlock = lazyContext

package/dist/server/agent-engine-api-key-route.d.ts

@@ -27,11 +27,11 @@ export declare function resolveAgentEngineApiKeyWriteTarget(event: H3Event, scop
 export declare function createAgentEngineApiKeyHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     error: any;
 } | {
-    error?: undefined;
     ok: boolean;
     key: string;
     baseUrlKey?: string;
     scope: AgentEngineApiKeyScope;
+    error?: undefined;
 }>>;
 export {};
 //# sourceMappingURL=agent-engine-api-key-route.d.ts.map

package/dist/server/email-actions.d.ts

@@ -5,8 +5,9 @@
  * Registered as a native tool in every template. sendEmail() checks the
  * scoped Resend/SendGrid configuration at call time.
  *
- * SAFETY: the action description instructs the agent to draft-first and only
- * send when the user explicitly confirms, matching the mail template convention.
+ * SAFETY: interactive runs are draft-first. Unattended automation runs are
+ * already authorized when the automation is created, so they get a separate
+ * description that permits delivery without interactive confirmation.
  *
  * COLLISION: the mail template registers its own richer "send-email" action.
  * The template's registration comes after this one in the spread, so it wins
@@ -14,5 +15,7 @@
  * action is keyed "core-send-email" which is distinct from the template name.
  */
 import type { ActionEntry } from "../agent/production-agent.js";
-export declare function createCoreEmailActionEntries(): Record<string, ActionEntry>;
+export declare function createCoreEmailActionEntries(options?: {
+    unattended?: boolean;
+}): Record<string, ActionEntry>;
 //# sourceMappingURL=email-actions.d.ts.map

package/dist/server/email-actions.js

@@ -5,103 +5,37 @@
  * Registered as a native tool in every template. sendEmail() checks the
  * scoped Resend/SendGrid configuration at call time.
  *
- * SAFETY: the action description instructs the agent to draft-first and only
- * send when the user explicitly confirms, matching the mail template convention.
+ * SAFETY: interactive runs are draft-first. Unattended automation runs are
+ * already authorized when the automation is created, so they get a separate
+ * description that permits delivery without interactive confirmation.
  *
  * COLLISION: the mail template registers its own richer "send-email" action.
  * The template's registration comes after this one in the spread, so it wins
  * when both would be present under the same key. To avoid any ambiguity this
  * action is keyed "core-send-email" which is distinct from the template name.
  */
+import { markdownToHtml, markdownToText, wrapInEmailTemplate, } from "./email-markdown.js";
 import { sendEmail } from "./email.js";
-function markdownToText(md) {
-    return md
-        .replace(/!\[([^\]]*)\]\([^\s)]+\)/g, "$1")
-        .replace(/\[([^\]]+)\]\([^\s)]+\)/g, "$1 ($2)")
-        .replace(/`([^`]+)`/g, "$1")
-        .replace(/\*\*([^*]+)\*\*/g, "$1")
-        .replace(/\*([^*\n]+)\*/g, "$1")
-        .replace(/^#{1,6}\s+/gm, "")
-        .trim();
-}
-function markdownToHtml(md) {
-    const normalized = md.replace(/\r\n/g, "\n").trim();
-    if (!normalized)
-        return "<p></p>";
-    // Escape HTML entities in a string, preserving already-encoded references.
-    const esc = (s) => s
-        .replace(/&/g, "&amp;")
-        .replace(/</g, "&lt;")
-        .replace(/>/g, "&gt;")
-        .replace(/"/g, "&quot;");
-    // Inline markdown: links, bold, italic, code, bare URLs.
-    const inline = (s) => s
-        .replace(/\[([^\]]+)\]\((https?:\/\/[^\s)]+)\)/g, (_m, label, url) => `<a href="${esc(url)}" target="_blank" rel="noopener noreferrer">${esc(label)}</a>`)
-        .replace(/(^|[^\w"'=])(https?:\/\/[^\s<]+)/g, (_m, pre, url) => `${pre}<a href="${esc(url)}" target="_blank" rel="noopener noreferrer">${esc(url)}</a>`)
-        .replace(/`([^`]+)`/g, (_m, code) => `<code>${esc(code)}</code>`)
-        .replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>")
-        .replace(/(^|[\s(])\*([^*\n]+)\*(?=$|[\s).,!?:;])/g, "$1<em>$2</em>");
-    const blocks = normalized.split(/\n{2,}/);
-    const html = blocks
-        .map((block) => {
-        const trimmed = block.trim();
-        // Fenced code block
-        if (trimmed.startsWith("```") && trimmed.endsWith("```")) {
-            const code = trimmed
-                .replace(/^```[^\n]*\n?/, "")
-                .replace(/\n?```$/, "");
-            return `<pre><code>${esc(code)}</code></pre>`;
-        }
-        // Heading
-        const hm = trimmed.match(/^(#{1,6})\s+(.+)$/);
-        if (hm) {
-            const level = hm[1].length;
-            return `<h${level}>${inline(hm[2])}</h${level}>`;
-        }
-        // Unordered list
-        if (/^[-*+]\s+/m.test(trimmed)) {
-            const items = trimmed
-                .split("\n")
-                .filter(Boolean)
-                .map((l) => `<li>${inline(l.replace(/^[-*+]\s+/, ""))}</li>`)
-                .join("");
-            return `<ul style="margin:0 0 1em;padding-left:1.5em">${items}</ul>`;
-        }
-        // Ordered list
-        if (/^\d+\.\s+/m.test(trimmed)) {
-            const items = trimmed
-                .split("\n")
-                .filter(Boolean)
-                .map((l) => `<li>${inline(l.replace(/^\d+\.\s+/, ""))}</li>`)
-                .join("");
-            return `<ol style="margin:0 0 1em;padding-left:1.5em">${items}</ol>`;
-        }
-        // Blockquote
-        if (trimmed.startsWith("> ")) {
-            const inner = trimmed
-                .split("\n")
-                .map((l) => (l.startsWith("> ") ? l.slice(2) : l))
-                .join("\n");
-            return `<blockquote style="margin:0 0 1em 1em;border-left:3px solid #ccc;padding-left:0.75em;color:#555">${inline(inner)}</blockquote>`;
-        }
-        return `<p style="margin:0 0 1em">${inline(trimmed).replace(/\n/g, "<br />")}</p>`;
-    })
-        .join("");
-    return html;
-}
-export function createCoreEmailActionEntries() {
+export function createCoreEmailActionEntries(options) {
+    const unattended = options?.unattended === true;
     return {
         "core-send-email": {
             tool: {
                 description: [
                     "Send a transactional email via the app's configured email provider (Resend or SendGrid).",
                     "",
-                    "IMPORTANT — DRAFT-FIRST SAFETY RULE: Never call this tool until the user has explicitly",
-                    "confirmed they want to send. Always compose the full email content first, show it to the",
-                    "user, and wait for an explicit 'yes, send it' before invoking this action.",
+                    ...(unattended
+                        ? [
+                            "This is an explicitly authorized unattended automation run. Send the email without asking for an interactive confirmation.",
+                        ]
+                        : [
+                            "IMPORTANT — DRAFT-FIRST SAFETY RULE: Never call this tool until the user has explicitly",
+                            "confirmed they want to send. Always compose the full email content first, show it to the",
+                            "user, and wait for an explicit 'yes, send it' before invoking this action.",
+                        ]),
                     "",
                     "The body is written in markdown. Tables, lists, bold, italic, links, and code blocks",
-                    "are all supported and will render correctly in email clients.",
+                    "are all supported and will render correctly in email clients. Write the body in markdown; do not hand-write HTML.",
                     "",
                     "This sends via the framework transport (Resend/SendGrid). It is NOT the Gmail-based",
                     "send-email action in the mail template — use this for system/notification emails from",
@@ -168,7 +102,7 @@ export function createCoreEmailActionEntries() {
                     await sendEmail({
                         to,
                         subject,
-                        html: markdownToHtml(bodyMd),
+                        html: wrapInEmailTemplate(markdownToHtml(bodyMd)),
                         text: markdownToText(bodyMd),
                         ...(from ? { from } : {}),
                         ...(cc ? { cc } : {}),

package/dist/server/email-markdown.d.ts

@@ -0,0 +1,4 @@
+export declare function markdownToText(md: string): string;
+export declare function markdownToHtml(md: string): string;
+export declare function wrapInEmailTemplate(bodyHtml: string): string;
+//# sourceMappingURL=email-markdown.d.ts.map

package/dist/server/email-markdown.js

@@ -0,0 +1,174 @@
+const EMAIL_BACKGROUND = "#f6f7f9"; // guard:allow-raw-color - email clients need inlined colors
+const EMAIL_TEXT = "#1f2937"; // guard:allow-raw-color - email clients need inlined colors
+const EMAIL_MUTED = "#64748b"; // guard:allow-raw-color - email clients need inlined colors
+const EMAIL_BORDER = "#dbe3ec"; // guard:allow-raw-color - email clients need inlined colors
+const EMAIL_CODE = "#eef2f7"; // guard:allow-raw-color - email clients need inlined colors
+const EMAIL_SURFACE = "#ffffff"; // guard:allow-raw-color - email clients need inlined colors
+function escapeHtml(value) {
+    return value
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/\"/g, "&quot;");
+}
+function inlineMarkdown(value) {
+    let html = escapeHtml(value);
+    const protectedLinks = [];
+    html = html.replace(/\[([^\]]+)\]\((https?:\/\/[^\s)]+)\)/g, (_match, label, url) => {
+        const index = protectedLinks.push(`<a href="${url}" style="color:${EMAIL_TEXT};text-decoration:underline;">${label}</a>`);
+        return `\u0000${index - 1}\u0000`;
+    });
+    html = html.replace(/(^|[^\w"'=])(https?:\/\/[^\s<]+)/g, (_match, prefix, rawUrl) => {
+        let url = rawUrl;
+        let trailing = "";
+        while (/[.,!?;:]$/.test(url)) {
+            trailing = url.slice(-1) + trailing;
+            url = url.slice(0, -1);
+        }
+        let label = "Open link";
+        const normalizedUrl = url.replace(/&amp;/g, "&");
+        if (URL.canParse(normalizedUrl)) {
+            const host = new URL(normalizedUrl).hostname.replace(/^www\./, "");
+            if (host)
+                label = `Open ${host}`;
+        }
+        return `${prefix}<a href="${url}" style="color:${EMAIL_TEXT};text-decoration:underline;">${label}</a>${trailing}`;
+    });
+    html = html
+        .replace(/`([^`]+)`/g, `<code style="background:${EMAIL_CODE};padding:2px 5px;border-radius:4px;font-size:0.92em;">$1</code>`)
+        .replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>")
+        .replace(/__([^_]+)__/g, "<strong>$1</strong>")
+        .replace(/(^|[\s(])\*([^*\n]+)\*(?=$|[\s).,!?:;])/g, "$1<em>$2</em>")
+        .replace(/(^|[\s(])_([^_\n]+)_(?=$|[\s).,!?:;])/g, "$1<em>$2</em>");
+    html = html.replace(/\u0000(\d+)\u0000/g, (_match, index) => {
+        return protectedLinks[Number(index)] ?? "";
+    });
+    return html;
+}
+function renderTable(lines) {
+    if (lines.length < 2 || !lines.every((line) => line.includes("|"))) {
+        return null;
+    }
+    const parseRow = (line) => line
+        .trim()
+        .replace(/^\|/, "")
+        .replace(/\|$/, "")
+        .split("|")
+        .map((cell) => cell.trim());
+    const header = parseRow(lines[0]);
+    const divider = parseRow(lines[1]);
+    if (!header.length || !divider.every((cell) => /^:?-{3,}:?$/.test(cell))) {
+        return null;
+    }
+    const body = lines.slice(2).map(parseRow);
+    const headHtml = header
+        .map((cell) => `<th align="left" style="border:1px solid ${EMAIL_BORDER};padding:8px 10px;background:${EMAIL_CODE};font-weight:600;">${inlineMarkdown(cell)}</th>`)
+        .join("");
+    const bodyHtml = body
+        .map((row) => `<tr>${header
+        .map((_cell, index) => `<td style="border:1px solid ${EMAIL_BORDER};padding:8px 10px;vertical-align:top;">${inlineMarkdown(row[index] ?? "")}</td>`)
+        .join("")}</tr>`)
+        .join("");
+    return `<div style="overflow-x:auto;margin:0 0 18px;"><table role="presentation" style="border-collapse:collapse;width:100%;font-size:14px;"><thead><tr>${headHtml}</tr></thead><tbody>${bodyHtml}</tbody></table></div>`;
+}
+export function markdownToText(md) {
+    return md
+        .replace(/^(?:```[^\n]*\n|```$)/gm, "")
+        .replace(/!\[([^\]]*)\]\([^\s)]+\)/g, "$1")
+        .replace(/\[([^\]]+)\]\(([^\s)]+)\)/g, "$1 ($2)")
+        .replace(/`([^`]+)`/g, "$1")
+        .replace(/\*\*([^*]+)\*\*/g, "$1")
+        .replace(/__([^_]+)__/g, "$1")
+        .replace(/(^|[\s(])\*([^*\n]+)\*(?=$|[\s).,!?:;])/gm, "$1$2")
+        .replace(/(^|[\s(])_([^_\n]+)_(?=$|[\s).,!?:;])/gm, "$1$2")
+        .replace(/^#{1,6}\s+/gm, "")
+        .replace(/^\s*[-*+]\s+/gm, "")
+        .replace(/^\s*\d+\.\s+/gm, "")
+        .replace(/^>\s?/gm, "")
+        .trim();
+}
+export function markdownToHtml(md) {
+    const lines = md.replace(/\r\n/g, "\n").trim().split("\n");
+    if (!md.trim())
+        return '<p style="margin:0;">&nbsp;</p>';
+    const blocks = [];
+    let index = 0;
+    while (index < lines.length) {
+        if (!lines[index].trim()) {
+            index += 1;
+            continue;
+        }
+        const line = lines[index].trim();
+        if (line.startsWith("```") &&
+            lines.slice(index + 1).some((item) => item.trim() === "```")) {
+            const end = lines.findIndex((item, offset) => offset > index && item.trim() === "```");
+            const code = lines.slice(index + 1, end).join("\n");
+            blocks.push(`<pre style="margin:0 0 18px;padding:14px 16px;background:${EMAIL_CODE};border-radius:6px;overflow-x:auto;white-space:pre-wrap;"><code>${escapeHtml(code)}</code></pre>`);
+            index = end + 1;
+            continue;
+        }
+        const heading = line.match(/^(#{1,6})\s+(.+)$/);
+        if (heading) {
+            const level = Math.min(heading[1].length, 3);
+            const sizes = ["24px", "19px", "16px"];
+            blocks.push(`<h${level} style="margin:0 0 10px;color:${EMAIL_TEXT};font-size:${sizes[level - 1]};line-height:1.3;">${inlineMarkdown(heading[2])}</h${level}>`);
+            index += 1;
+            continue;
+        }
+        if (/^(?:-{3,}|\*{3,})$/.test(line)) {
+            blocks.push(`<hr style="border:0;border-top:1px solid ${EMAIL_BORDER};margin:4px 0 18px;" />`);
+            index += 1;
+            continue;
+        }
+        const listMatch = line.match(/^([-*+] |\d+\. )/);
+        if (listMatch) {
+            const ordered = /^\d/.test(listMatch[1]);
+            const items = [];
+            while (index < lines.length) {
+                const item = lines[index]
+                    .trim()
+                    .match(ordered ? /^\d+\.\s+(.+)$/ : /^[-*+]\s+(.+)$/);
+                if (!item)
+                    break;
+                items.push(`<li style="margin:0 0 6px;">${inlineMarkdown(item[1])}</li>`);
+                index += 1;
+            }
+            const tag = ordered ? "ol" : "ul";
+            blocks.push(`<${tag} style="margin:0 0 18px;padding-left:24px;">${items.join("")}</${tag}>`);
+            continue;
+        }
+        const tableLines = [line];
+        let tableEnd = index + 1;
+        while (tableEnd < lines.length &&
+            lines[tableEnd].trim() &&
+            lines[tableEnd].includes("|")) {
+            tableLines.push(lines[tableEnd].trim());
+            tableEnd += 1;
+        }
+        const table = renderTable(tableLines);
+        if (table) {
+            blocks.push(table);
+            index = tableEnd;
+            continue;
+        }
+        const paragraph = [line];
+        index += 1;
+        while (index < lines.length && lines[index].trim()) {
+            if (/^(?:#{1,6}\s|[-*+]\s|\d+\.\s|>\s|```)/.test(lines[index].trim()))
+                break;
+            paragraph.push(lines[index].trim());
+            index += 1;
+        }
+        if (paragraph.every((item) => item.startsWith("> "))) {
+            blocks.push(`<blockquote style="margin:0 0 18px;padding:4px 0 4px 14px;border-left:3px solid ${EMAIL_BORDER};color:${EMAIL_MUTED};">${inlineMarkdown(paragraph.map((item) => item.slice(2)).join("\n")).replace(/\n/g, "<br />")}</blockquote>`);
+        }
+        else {
+            blocks.push(`<p style="margin:0 0 18px;line-height:1.65;">${inlineMarkdown(paragraph.join("\n")).replace(/\n/g, "<br />")}</p>`);
+        }
+    }
+    return blocks.join("\n");
+}
+export function wrapInEmailTemplate(bodyHtml) {
+    return `<!DOCTYPE html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"></head><body style="margin:0;padding:0;background:${EMAIL_BACKGROUND};font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,Helvetica,Arial,sans-serif;color:${EMAIL_TEXT};"><div style="padding:24px 12px;"><div style="box-sizing:border-box;max-width:640px;margin:0 auto;padding:28px 30px;background:${EMAIL_SURFACE};border:1px solid ${EMAIL_BORDER};border-radius:8px;font-size:15px;line-height:1.65;">${bodyHtml}</div></div></body></html>`;
+}
+//# sourceMappingURL=email-markdown.js.map

package/dist/server/transcribe-voice.d.ts

@@ -20,7 +20,7 @@ export declare function createTranscribeVoiceHandler(): import("h3").EventHandle
     error: string;
     text?: undefined;
 } | {
-    error?: undefined;
     text: string;
+    error?: undefined;
 }>>;
 //# sourceMappingURL=transcribe-voice.d.ts.map

package/dist/templates/workspace-core/.agents/skills/automations/SKILL.md

@@ -103,6 +103,7 @@ All automation operations are accessed through a single `manage-automations` too
 | `update`      | Update an existing automation (enabled, condition, body)             |
 | `delete`      | Delete an automation (always confirm with user first)                |
 | `fire-test`   | Emit a `test.event.fired` event to validate automations              |
+| `run-now`     | Run one automation immediately with its real actions and side effects |
 
 Additional tool: `web-request` — outbound HTTP with `${keys.NAME}` substitution.
 

package/dist/triggers/actions.d.ts

@@ -5,7 +5,7 @@
  * available in every template. The agent uses them to create, list, and
  * manage automations from chat.
  *
- * All six operations are consolidated into a single `manage-automations` tool
+ * All seven operations are consolidated into a single `manage-automations` tool
  * with an `action` discriminator to keep the tool registry compact.
  */
 import type { ActionEntry } from "../agent/production-agent.js";