loopengine 0.2.2 → 0.3.1

package/dist/web/templates-admin.js

@@ -15,6 +15,11 @@ import { ActauthRuleExistsError, addActauthRule, setDefaultDecision } from './ac
 import { setAgentEnvVar } from './env-admin.js';
 import { freeAgentName } from './interview-admin.js';
 import { writeSkill } from './skills-admin.js';
+/** What a template's schedule runs (its workflow, when it comes from one,
+ * or its message), and whether it sends each result. */
+function scheduleRuns(schedule) {
+    return { ...(schedule.workflowId ? { workflow_id: schedule.workflowId } : { message: schedule.message }), ...(schedule.notify ? { notify: true } : {}) };
+}
 export class TemplateError extends Error {
 }
 /** A failed install, in a line the checklist can show: npm's own output
@@ -201,7 +206,7 @@ export async function createFromTemplateObject(template, deps) {
             const startAt = templateScheduleStart(setup.schedule);
             const task = await createScheduledTask({
                 agent: name,
-                message: setup.schedule.message,
+                ...scheduleRuns(setup.schedule),
                 schedule: { every: setup.schedule.every, ...(startAt ? { start_at: startAt } : {}) },
                 task_name: setup.schedule.name,
             });
@@ -246,7 +251,7 @@ async function createFromTemplateLegacy(id, deps) {
     if (setup.schedule) {
         try {
             const startAt = templateScheduleStart(setup.schedule);
-            const task = await createScheduledTask({ agent: name, message: setup.schedule.message, schedule: { every: setup.schedule.every, ...(startAt ? { start_at: startAt } : {}) }, task_name: setup.schedule.name });
+            const task = await createScheduledTask({ agent: name, ...scheduleRuns(setup.schedule), schedule: { every: setup.schedule.every, ...(startAt ? { start_at: startAt } : {}) }, task_name: setup.schedule.name });
             await pauseScheduledTask(task.task_id);
             schedule = { description: describeTemplateSchedule(setup.schedule), timeZone: workspaceTimeZone(), ...(startAt ? { next_run_at: startAt } : {}) };
         }

package/dist/web/workflow-admin.d.ts

@@ -2,7 +2,8 @@ import { type CreatedTemplateAgent, type TemplateChecklistItem, type TemplateCre
 import { type WorkflowPlan, type WorkflowPlannerTools } from '../core/system-agents/workflow-planner.js';
 import { type GeneratedMcpAbility, type McpAbilityRequest } from '../core/mcp-ability-generator.js';
 import type { McpDirectoryServer } from '../core/mcp-directory.js';
-import { type WorkflowRecord } from '../core/workflows.js';
+import { type Workflow } from '../core/workflows.js';
+import { type WorkflowRun } from '../core/workflow-runs.js';
 import type { ModelCall } from '../core/run-agent.js';
 export declare class WorkflowError extends Error {
 }
@@ -147,24 +148,48 @@ export declare function createWorkflow(input: {
     description?: unknown;
     mcpKeys?: unknown;
 }, deps: WorkflowCreateDeps): Promise<CreatedWorkflow>;
-export interface AgentWorkflowView extends WorkflowRecord {
-    schedule?: {
-        taskId: string;
-        status: string;
-        nextRunAt?: string;
-        lastRunAt?: string;
-        lastStatus?: string;
-        waiting: boolean;
-    };
+type WorkflowScheduleView = {
+    taskId: string;
+    status: string;
+    repeating: boolean;
+    params?: Record<string, string>;
+    nextRunAt?: string;
+    lastRunAt?: string;
+    lastStatus?: string;
+    waiting: boolean;
+};
+export interface AgentWorkflowView extends Workflow {
+    /** Its main schedule: a repeating one if it has one. */
+    schedule?: WorkflowScheduleView;
+    /** Every live task that runs it, repeating ones first. */
+    schedules: WorkflowScheduleView[];
+    /** Its latest runs started by hand or by an app, newest first. */
+    recentRuns: WorkflowRun[];
 }
-/** An agent's workflows, each with its schedule's state when it has one. */
+/** Moves an agent's workflows.yml, from before workflows were skills, into
+ * its skills, and points the schedules it linked by name at the workflows
+ * they run. Safe to call any time: it does nothing once the file is gone. */
+export declare function migrateAgentWorkflows(agentName: string, agentDir: string): Promise<void>;
+/** An agent's workflows, each with the state of the tasks that run it. */
 export declare function listAgentWorkflows(agentName: string, agentDir: string): Promise<AgentWorkflowView[]>;
-/** Starts a workflow now: its schedule runs once (a paused one goes back
- * to paused after), or, with no schedule, a one-off run. Questions and
- * approvals go to the agent's messaging app. */
-export declare function runWorkflowNow(agentName: string, agentDir: string, id: string): Promise<{
-    taskId: string;
+/** Gets a run of a workflow ready to start, with these parameters: checks
+ * them, and that a run with the same parameters isn't already under way
+ * (runs with other parameters go ahead), and works out the message it
+ * starts with — the workflow's start message and steps as they are now.
+ * The server starts it (core/workflow-runs.ts). */
+export declare function prepareWorkflowRun(agentName: string, agentDir: string, id: string, rawParams?: unknown): Promise<{
+    workflow: Workflow;
+    params: Record<string, string>;
+    message: string;
+}>;
+/** Changes how a workflow's runs start, from the console's workflow
+ * editor: its title, start message, trigger and parameters. Its steps
+ * (the skill body) and the skill's other front matter are kept. */
+export declare function updateWorkflow(agentDir: string, id: string, input: Record<string, unknown>): Workflow;
+/** Forgets a workflow: its skill stays, as a plain skill, and the
+ * schedules that ran it are cancelled. Returns how many were. */
+export declare function forgetWorkflow(agentName: string, agentDir: string, id: string): Promise<{
+    cancelled: number;
 }>;
-/** Forgets a workflow (its skill, schedule and rules stay). */
-export declare function forgetWorkflow(agentDir: string, id: string): void;
 export declare function agentDirIn(projectDir: string, name: string): string;
+export {};

package/dist/web/workflow-admin.js

@@ -10,10 +10,11 @@ import { addActauthRule, readActauthConfig } from './actauth-admin.js';
 import { writeSkill } from './skills-admin.js';
 import { createFromTemplateObject, installFailureReason, templateChecklist } from './templates-admin.js';
 import { templateScheduleStart } from '../core/system-agents/templates.js';
-import { planWorkflowWithModel, slugify, workflowTemplate } from '../core/system-agents/workflow-planner.js';
+import { planParameters, planWorkflowWithModel, slugify, workflowTemplate } from '../core/system-agents/workflow-planner.js';
 import { mcpAbilityNames } from '../core/mcp-ability-generator.js';
-import { readWorkflows, removeWorkflow, saveWorkflow } from '../core/workflows.js';
-import { createScheduledTask, listScheduledTasks, pauseScheduledTask, runScheduledTaskNow } from '../core/scheduler.js';
+import { clearWorkflowFields, migrateWorkflowsFile, readWorkflow, readWorkflows, setWorkflowFields, validateParams, workflowRunMessage } from '../core/workflows.js';
+import { isUnderWay, listRuns } from '../core/workflow-runs.js';
+import { cancelScheduledTask, createScheduledTask, getSchedulerStore, listScheduledTasks, pauseScheduledTask } from '../core/scheduler.js';
 import { workspaceTimeZone } from '../core/time-zone.js';
 export class WorkflowError extends Error {
 }
@@ -304,18 +305,11 @@ export async function createWorkflow(input, deps) {
     if (!plan || typeof plan !== 'object' || !Array.isArray(plan.steps) || !plan.skill || !plan.newAgent)
         throw new WorkflowError('Plan the workflow first.');
     const target = (input.target ?? plan.target);
-    const description = typeof input.description === 'string' ? input.description.trim().slice(0, 4000) : undefined;
-    const record = (scheduleName) => ({
-        id: plan.id,
-        name: plan.name,
-        summary: plan.summary,
-        trigger: { kind: plan.trigger.kind, description: plan.trigger.description },
-        steps: plan.steps,
-        startMessage: plan.startMessage,
-        ...(scheduleName ? { scheduleName } : {}),
-        ...(description ? { description } : {}),
-        createdAt: new Date().toISOString(),
-    });
+    // The plan's skill becomes a workflow: how a run starts, in its front
+    // matter. Its parameters are tidied again, as the plan may have been
+    // edited on the review screen.
+    const { parameters } = planParameters(plan.parameters, { startMessage: plan.startMessage, skillBody: plan.skill.body, scheduled: plan.trigger.kind === 'schedule' });
+    const markWorkflow = (agentDir) => setWorkflowFields(agentDir, plan.id, { title: plan.name, startMessage: plan.startMessage, trigger: plan.trigger.description, parameters });
     const agents = await deps.agentInfo();
     resolveConnections(plan, agents);
     const keys = input.mcpKeys && typeof input.mcpKeys === 'object' ? Object.fromEntries(Object.entries(input.mcpKeys).flatMap(([k, v]) => (typeof v === 'string' && v.trim() ? [[k, v.trim()]] : []))) : {};
@@ -326,7 +320,7 @@ export async function createWorkflow(input, deps) {
         // Read on its next run: the agent needs no reloading for it.
         const connected = copyConnectedTools(plan, created.name, agents, deps.agentDir);
         const loadError = created.loadError;
-        saveWorkflow(deps.agentDir(created.name), record(created.schedule ? plan.name : undefined));
+        markWorkflow(deps.agentDir(created.name));
         return {
             agent: created.name,
             newAgent: true,
@@ -426,7 +420,8 @@ export async function createWorkflow(input, deps) {
             const startAt = templateScheduleStart(template.setup.schedule);
             const task = await createScheduledTask({
                 agent: agent.name,
-                message: plan.startMessage,
+                workflow_id: plan.id,
+                ...(plan.notify?.on ? { notify: true } : {}),
                 schedule: { every: template.setup.schedule.every, ...(startAt ? { start_at: startAt } : {}) },
                 task_name: plan.name,
             });
@@ -437,7 +432,7 @@ export async function createWorkflow(input, deps) {
             scheduleError = err instanceof Error ? err.message : String(err);
         }
     }
-    saveWorkflow(deps.agentDir(agent.name), record(schedule ? plan.name : undefined));
+    markWorkflow(deps.agentDir(agent.name));
     return {
         agent: agent.name,
         newAgent: false,
@@ -450,50 +445,122 @@ export async function createWorkflow(input, deps) {
         ...(loadError ? { loadError } : {}),
     };
 }
-/** An agent's workflows, each with its schedule's state when it has one. */
+const RECENT_RUNS = 5;
+/** The live tasks that run a workflow: those carrying its id. */
+function workflowTasks(id, tasks) {
+    return tasks
+        .filter((t) => t.workflow_id === id && t.status !== 'cancelled' && t.status !== 'done')
+        .sort((a, b) => Number('every' in b.schedule) - Number('every' in a.schedule));
+}
+function scheduleView(task) {
+    return {
+        taskId: task.task_id,
+        status: task.status,
+        repeating: 'every' in task.schedule,
+        ...(task.params ? { params: task.params } : {}),
+        ...(task.next_run_at ? { nextRunAt: task.next_run_at } : {}),
+        ...(task.last_run_at ? { lastRunAt: task.last_run_at } : {}),
+        ...(task.last_status ? { lastStatus: task.last_status } : {}),
+        waiting: Boolean(task.pending) || task.status === 'awaiting_approval',
+    };
+}
+/** Moves an agent's workflows.yml, from before workflows were skills, into
+ * its skills, and points the schedules it linked by name at the workflows
+ * they run. Safe to call any time: it does nothing once the file is gone. */
+export async function migrateAgentWorkflows(agentName, agentDir) {
+    const moved = migrateWorkflowsFile(agentDir);
+    if (!moved.length)
+        return;
+    for (const task of await listScheduledTasks({ agent: agentName })) {
+        const match = !task.workflow_id && task.status !== 'cancelled' && moved.find((m) => m.scheduleName && m.scheduleName === task.task_name);
+        if (!match)
+            continue;
+        await getSchedulerStore().update(task.task_id, (t) => t && { ...t, workflow_id: match.id, message: '' });
+    }
+}
+/** An agent's workflows, each with the state of the tasks that run it. */
 export async function listAgentWorkflows(agentName, agentDir) {
+    await migrateAgentWorkflows(agentName, agentDir);
     const workflows = readWorkflows(agentDir);
     if (!workflows.length)
         return [];
     const tasks = await listScheduledTasks({ agent: agentName });
+    const runs = await listRuns(agentName);
     return workflows.map((w) => {
-        const task = w.scheduleName ? tasks.find((t) => t.task_name === w.scheduleName && t.status !== 'cancelled') : undefined;
-        return task
-            ? {
-                ...w,
-                schedule: {
-                    taskId: task.task_id,
-                    status: task.status,
-                    ...(task.next_run_at ? { nextRunAt: task.next_run_at } : {}),
-                    ...(task.last_run_at ? { lastRunAt: task.last_run_at } : {}),
-                    ...(task.last_status ? { lastStatus: task.last_status } : {}),
-                    waiting: Boolean(task.pending) || task.status === 'awaiting_approval',
-                },
-            }
-            : w;
+        const schedules = workflowTasks(w.id, tasks).map(scheduleView);
+        const recentRuns = runs.filter((r) => r.workflow_id === w.id).slice(0, RECENT_RUNS);
+        return { ...w, schedules, recentRuns, ...(schedules[0] ? { schedule: schedules[0] } : {}) };
     });
 }
-/** Starts a workflow now: its schedule runs once (a paused one goes back
- * to paused after), or, with no schedule, a one-off run. Questions and
- * approvals go to the agent's messaging app. */
-export async function runWorkflowNow(agentName, agentDir, id) {
-    const workflow = readWorkflows(agentDir).find((w) => w.id === id);
+function sameParams(a, b) {
+    const left = a ?? {};
+    const keys = new Set([...Object.keys(left), ...Object.keys(b)]);
+    return [...keys].every((k) => (left[k] ?? '') === (b[k] ?? ''));
+}
+/** Gets a run of a workflow ready to start, with these parameters: checks
+ * them, and that a run with the same parameters isn't already under way
+ * (runs with other parameters go ahead), and works out the message it
+ * starts with — the workflow's start message and steps as they are now.
+ * The server starts it (core/workflow-runs.ts). */
+export async function prepareWorkflowRun(agentName, agentDir, id, rawParams) {
+    const workflow = readWorkflow(agentDir, id);
     if (!workflow)
         throw new WorkflowError(`No workflow ${id} in ${agentName}.`);
-    const views = await listAgentWorkflows(agentName, agentDir);
-    const task = views.find((w) => w.id === id)?.schedule;
-    if (task) {
-        if (task.status === 'running' || task.waiting)
-            throw new WorkflowError('It is already running, or waiting for a decision.');
-        await runScheduledTaskNow(task.taskId);
-        return { taskId: task.taskId };
+    let params;
+    try {
+        params = validateParams(workflow, rawParams);
+    }
+    catch (err) {
+        throw new WorkflowError(err instanceof Error ? err.message : String(err));
+    }
+    const runs = await listRuns(agentName, { workflowId: id });
+    if (runs.some((r) => isUnderWay(r) && sameParams(r.params, params))) {
+        throw new WorkflowError(`${workflow.title} is already running${Object.keys(params).length ? ' with these parameters' : ''}, or waiting for a decision.`);
     }
-    const once = await createScheduledTask({ agent: agentName, message: workflow.startMessage, schedule: { run_at: new Date().toISOString() }, task_name: `${workflow.name} (run now)` });
-    return { taskId: once.task_id };
+    return { workflow, params, message: workflowRunMessage(workflow, params) };
 }
-/** Forgets a workflow (its skill, schedule and rules stay). */
-export function forgetWorkflow(agentDir, id) {
-    removeWorkflow(agentDir, id);
+/** Changes how a workflow's runs start, from the console's workflow
+ * editor: its title, start message, trigger and parameters. Its steps
+ * (the skill body) and the skill's other front matter are kept. */
+export function updateWorkflow(agentDir, id, input) {
+    if (!readWorkflow(agentDir, id))
+        throw new WorkflowError(`No workflow ${id}.`);
+    const text = (value, field, max) => {
+        if (value !== undefined && value !== null && typeof value !== 'string')
+            throw new WorkflowError(`${field} must be text.`);
+        const trimmed = (value ?? '').toString().trim();
+        if (trimmed.length > max)
+            throw new WorkflowError(`${field} is too long: keep it under ${max} characters.`);
+        return trimmed;
+    };
+    const title = text(input.title, 'The title', 120);
+    const startMessage = text(input.start_message, 'The start message', 4000);
+    if (!startMessage)
+        throw new WorkflowError('Write the start message: what each run begins with, e.g. "Check the refund request for order $order_number."');
+    const trigger = text(input.trigger, 'When it runs', 200);
+    const raw = input.parameters ?? {};
+    if (typeof raw !== 'object' || Array.isArray(raw))
+        throw new WorkflowError('parameters must be an object of names to { description, required }.');
+    const parameters = {};
+    for (const [name, spec] of Object.entries(raw)) {
+        if (!/^[a-z_][a-z0-9_]*$/.test(name))
+            throw new WorkflowError(`Parameter "${name}": use lowercase letters, digits and _, starting with a letter, e.g. "order_number".`);
+        const s = spec && typeof spec === 'object' ? spec : {};
+        parameters[name] = { description: text(s.description, `The description of "${name}"`, 300), required: s.required === true };
+    }
+    setWorkflowFields(agentDir, id, { ...(title ? { title } : {}), startMessage, ...(trigger ? { trigger } : {}), parameters });
+    return readWorkflow(agentDir, id);
+}
+/** Forgets a workflow: its skill stays, as a plain skill, and the
+ * schedules that ran it are cancelled. Returns how many were. */
+export async function forgetWorkflow(agentName, agentDir, id) {
+    clearWorkflowFields(agentDir, id);
+    let cancelled = 0;
+    for (const task of workflowTasks(id, await listScheduledTasks({ agent: agentName }))) {
+        await cancelScheduledTask(task.task_id);
+        cancelled++;
+    }
+    return { cancelled };
 }
 export function agentDirIn(projectDir, name) {
     return join(projectDir, 'agents', name);

package/dist/web/workflow-page.js

@@ -28,6 +28,12 @@ export const workflowPageHtml = `<!doctype html>
   .wf-num { width: 24px; color: var(--ink-muted); }
   .wf-target { display: grid; gap: 8px; }
   .wf-target label { display: flex; gap: 8px; align-items: center; font-size: 13.5px; }
+  .wf-notify { display: flex; gap: 8px; align-items: center; font-size: 13.5px; }
+  .wf-notify input { margin: 0; }
+  .wf-params { display: grid; gap: 6px; }
+  .wf-param { display: flex; gap: 8px; align-items: center; flex-wrap: wrap; font-size: 13px; }
+  .wf-param .wf-param-name { width: 160px; font-family: var(--mono, monospace); }
+  .wf-param .wf-param-desc { flex: 1; min-width: 200px; }
   .wf-gaps { border: 1px solid var(--warn); background: var(--warn-soft); border-radius: var(--radius); padding: 10px 14px; }
   .wf-gaps ul, .wf-list { margin: 4px 0 0; padding-left: 18px; }
   .wf-gaps li, .wf-list li { margin: 3px 0; font-size: 13px; }
@@ -174,6 +180,54 @@ ${consoleShellScript}
       '</div>';
   }
 
+  // The $names a plan's start message and steps use: those parameters
+  // can't be removed here (the text needs them), only described.
+  function usedParamNames(p) {
+    var used = {};
+    var pattern = new RegExp('[$]([a-z_][a-z0-9_]*)', 'g');
+    var text = (p.startMessage || '') + ' ' + ((p.skill && p.skill.body) || '');
+    var m;
+    while ((m = pattern.exec(text))) used[m[1]] = true;
+    return used;
+  }
+
+  function paramRowHtml(name, spec, used) {
+    var fixed = name !== null;
+    return '<div class="wf-param"' + (fixed ? ' data-name="' + esc(name) + '"' : '') + '>' +
+      (fixed ? '<code class="wf-param-name">' + esc(name) + '</code>' : '<input class="wf-param-name" aria-label="Parameter name" placeholder="order_number">') +
+      '<input class="wf-param-desc" aria-label="What it is" placeholder="What it is" value="' + esc((spec && spec.description) || '') + '">' +
+      '<label><input type="checkbox" class="wf-param-required"' + (spec && spec.required ? ' checked' : '') + '> Required</label>' +
+      (fixed && used[name] ? '<span class="hint">used in the steps</span>' : '<button type="button" class="wf-btn plain wf-param-remove">Remove</button>') +
+      '</div>';
+  }
+
+  function paramsSectionHtml(p) {
+    var used = usedParamNames(p);
+    var names = Object.keys(p.parameters || {});
+    return '<h3>What each run is given</h3>' +
+      '<p class="hint" style="margin:0"><strong>Each run starts with:</strong> ' + esc(p.startMessage) + '</p>' +
+      '<p class="hint" style="margin:0">' + (names.length
+        ? 'Apps and people fill these in when they start a run; each $name in the start message and steps becomes its value.'
+        : 'Every run is the same. Add a parameter if something changes from run to run, such as an order number.') + '</p>' +
+      '<div class="wf-params" id="wfParams">' + names.map(function (n) { return paramRowHtml(n, p.parameters[n], used); }).join('') + '</div>' +
+      '<div><button type="button" class="wf-btn plain" id="wfAddParam">Add a parameter</button></div>';
+  }
+
+  // The parameters as edited on the plan; an error message for a bad name.
+  function readParams() {
+    var parameters = {};
+    var rows = page.querySelectorAll('#wfParams .wf-param');
+    for (var i = 0; i < rows.length; i++) {
+      var input = rows[i].querySelector('input.wf-param-name');
+      var name = rows[i].dataset.name || (input ? input.value.trim() : '');
+      if (!name) continue;
+      if (!/^[a-z_][a-z0-9_]*$/.test(name)) return { error: 'Parameter "' + name + '": use lowercase letters, digits and _, starting with a letter, e.g. order_number.' };
+      if (parameters[name]) return { error: 'Parameter "' + name + '" is listed twice.' };
+      parameters[name] = { description: rows[i].querySelector('.wf-param-desc').value.trim(), required: rows[i].querySelector('.wf-param-required').checked };
+    }
+    return { parameters: parameters };
+  }
+
   function renderPlan(error) {
     var p = state.planned.plan;
     var suggested = p.target.kind === 'existing' && p.target.agent ? p.target.agent : '';
@@ -182,6 +236,11 @@ ${consoleShellScript}
       '<div class="wf-card">' +
         '<h2>' + esc(p.name) + '</h2><p style="margin:0">' + esc(p.summary) + '</p>' +
         '<p class="hint" style="margin:0"><strong>Starts:</strong> ' + esc(p.trigger.description) + (p.trigger.kind === 'schedule' ? ' (created paused; you turn it on)' : '') + '</p>' +
+        (p.trigger.kind === 'schedule'
+          ? '<label class="wf-notify"><input type="checkbox" id="wfNotify"' + (p.notify && p.notify.on ? ' checked' : '') + '> Send each run' + String.fromCharCode(8217) + 's result to you through the agent' + String.fromCharCode(8217) + 's messaging app</label>' +
+            (p.notify && p.notify.reason ? '<p class="hint" style="margin:0 0 0 24px">' + esc(p.notify.reason) + '</p>' : '')
+          : '') +
+        paramsSectionHtml(p) +
         '<h3>Steps</h3>' +
         '<div class="le-table-wrap"><table class="wf-steps"><thead><tr><th></th><th>Step</th><th>Becomes</th><th>Checkpoint</th></tr></thead><tbody>' + p.steps.map(stepRow).join('') + '</tbody></table></div>' +
         (p.rules.length ? '<h3>Permissions it sets</h3><ul class="wf-list">' + p.rules.map(function (r) { return '<li><code>' + esc(r.tool) + '</code> ' + pill(r.decision) + '</li>'; }).join('') + '</ul>' : '') +
@@ -206,7 +265,20 @@ ${consoleShellScript}
         '<span class="hint" id="wfStatus"></span></div>' +
       (error ? '<p class="error">' + esc(error) + '</p>' : '');
     document.getElementById('wfBack').addEventListener('click', function () { renderDescribe(); });
+    var paramsBox = document.getElementById('wfParams');
+    paramsBox.addEventListener('click', function (ev) {
+      if (ev.target.classList.contains('wf-param-remove')) ev.target.closest('.wf-param').remove();
+    });
+    document.getElementById('wfAddParam').addEventListener('click', function () {
+      paramsBox.insertAdjacentHTML('beforeend', paramRowHtml(null, null, {}));
+      paramsBox.lastElementChild.querySelector('input.wf-param-name').focus();
+    });
     document.getElementById('wfCreate').addEventListener('click', function () {
+      var edited = readParams();
+      if (edited.error) { document.getElementById('wfStatus').textContent = edited.error; return; }
+      p.parameters = edited.parameters;
+      var notifyBox = document.getElementById('wfNotify');
+      if (notifyBox) p.notify = { on: notifyBox.checked, reason: (p.notify && p.notify.reason) || '' };
       var chosen = page.querySelector('input[name="wfTarget"]:checked');
       var target = chosen.value === 'new' ? { kind: 'new' } : { kind: 'existing', agent: chosen.value === 'other' ? document.getElementById('wfOther').value : chosen.dataset.agent };
       var btn = document.getElementById('wfCreate');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loopengine",
-  "version": "0.2.2",
+  "version": "0.3.1",
   "type": "module",
   "description": "Runtime for tool-using AI agents with a transparent ReAct loop.",
   "license": "MIT",
@@ -124,6 +124,12 @@
     "dist/core/durable-approvals.d.ts",
     "dist/core/workflows.js",
     "dist/core/workflows.d.ts",
+    "dist/core/workflow-runs.js",
+    "dist/core/workflow-runs.d.ts",
+    "dist/core/run-callbacks.js",
+    "dist/core/run-callbacks.d.ts",
+    "dist/core/workflow-triggers.js",
+    "dist/core/workflow-triggers.d.ts",
     "dist/web",
     "protocol/loop-event.schema.json",
     "PROTOCOL.md",