bosun 0.35.3 → 0.35.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bosun",
-  "version": "0.35.3",
+  "version": "0.35.4",
   "description": "AI-powered orchestrator supervisor — manages AI agent executors with failover, auto-restarts on failure, analyzes crashes with Codex SDK, creates PRs via Vibe-Kanban API, and sends Telegram notifications. Supports N executors with weighted distribution, multi-repo projects, and auto-setup.",
   "type": "module",
   "license": "Apache 2.0",

package/session-tracker.mjs

@@ -218,6 +218,21 @@ export class SessionTracker {
         ? this.#maxMessages
         : session.maxMessages;
 
+    if (typeof event === "string" && event.trim()) {
+      const msg = {
+        type: "system",
+        content: event.trim().slice(0, MAX_MESSAGE_CHARS),
+        timestamp: new Date().toISOString(),
+      };
+      session.messages.push(msg);
+      if (Number.isFinite(maxMessages) && maxMessages > 0) {
+        while (session.messages.length > maxMessages) session.messages.shift();
+      }
+      this.#markDirty(taskId);
+      emitSessionEvent(session, msg);
+      return;
+    }
+
     // Direct message format (role/content)
     if (event && event.role && event.content !== undefined) {
       const msg = {
@@ -761,7 +776,7 @@ export class SessionTracker {
     };
 
     // ── Codex SDK events ──
-    if (event.type === "item.completed" && event.item) {
+    if ((event.type === "item.completed" || event.type === "item.updated") && event.item) {
       const item = event.item;
       const itemType = String(item.type || "").toLowerCase();
 
@@ -823,6 +838,20 @@ ${output}`
         };
       }
 
+      if (
+        itemType === "agent_message" &&
+        event.type === "item.updated" &&
+        (item.text || item.delta)
+      ) {
+        const partial = toText(item.text || item.delta);
+        if (!partial) return null;
+        return {
+          type: "agent_message",
+          content: partial.slice(0, MAX_MESSAGE_CHARS),
+          timestamp: ts,
+        };
+      }
+
       if (itemType === "file_change") {
         const changes = Array.isArray(item.changes)
           ? item.changes
@@ -876,6 +905,31 @@ ${items.join("\n")}` : "todo updated";
       return null; // Skip other item types
     }
 
+    if (event.type === "item.started" && event.item) {
+      const item = event.item;
+      const itemType = String(item.type || "").toLowerCase();
+
+      if (itemType === "command_execution") {
+        const command = toText(item.command || item.input || "").trim();
+        return {
+          type: "tool_call",
+          content: command || "(command)",
+          timestamp: ts,
+          meta: { toolName: "command_execution" },
+        };
+      }
+
+      if (itemType === "reasoning") {
+        const detail = toText(item.text || item.summary || "").trim();
+        if (!detail) return null;
+        return {
+          type: "system",
+          content: detail.slice(0, MAX_MESSAGE_CHARS),
+          timestamp: ts,
+        };
+      }
+    }
+
     if (event.type === "assistant.message" && event.data?.content) {
       return {
         type: "agent_message",

package/ui/demo.html

@@ -3073,6 +3073,25 @@
           }),
         };
       }
+      if (route === '/api/workflows/template-updates') {
+        const updates = (STATE.workflows || [])
+          .map((wf) => {
+            const state = wf?.metadata?.templateState || null;
+            if (!state?.templateId) return null;
+            return {
+              workflowId: wf.id,
+              workflowName: wf.name,
+              templateId: state.templateId,
+              templateName: state.templateName || state.templateId,
+              updateAvailable: state.updateAvailable === true,
+              isCustomized: state.isCustomized === true,
+              templateVersion: state.templateVersion || null,
+              installedTemplateVersion: state.installedTemplateVersion || null,
+            };
+          })
+          .filter(Boolean);
+        return { ok: true, updates };
+      }
       if (route.startsWith('/api/workflows/runs/')) {
         const runId = decodeURIComponent(route.replace('/api/workflows/runs/', '')).trim();
         const run = STATE.workflowRuns.find((item) => item.runId === runId);
@@ -3124,6 +3143,36 @@
         const segs = route.replace('/api/workflows/', '').split('/');
         const wfId = segs[0];
         const action = segs[1] || '';
+        if (action === 'template-update') {
+          const wf = STATE.workflows.find(w => w.id === wfId);
+          if (!wf) return { ok: false, error: 'Workflow not found' };
+          if ((body?.mode || 'replace') === 'copy') {
+            const copy = JSON.parse(JSON.stringify(wf));
+            copy.id = 'wf-' + Math.random().toString(36).slice(2, 9);
+            copy.name = `${wf.name} (Updated)`;
+            copy.metadata = {
+              ...(copy.metadata || {}),
+              updatedAt: new Date().toISOString(),
+              templateState: {
+                ...(copy.metadata?.templateState || {}),
+                updateAvailable: false,
+                isCustomized: false,
+              },
+            };
+            STATE.workflows.push(copy);
+            return { ok: true, workflow: copy };
+          }
+          wf.metadata = {
+            ...(wf.metadata || {}),
+            updatedAt: new Date().toISOString(),
+            templateState: {
+              ...(wf.metadata?.templateState || {}),
+              updateAvailable: false,
+              isCustomized: false,
+            },
+          };
+          return { ok: true, workflow: wf };
+        }
         if (action === 'execute') {
           const run = { runId: 'run-' + Math.random().toString(36).slice(2, 6), workflowId: wfId, status: 'completed', nodeCount: 6, duration: 30000 + Math.floor(Math.random() * 30000), errorCount: 0, startedAt: new Date().toISOString() };
           STATE.workflowRuns.unshift(run);

package/ui/tabs/workflows.js

@@ -184,6 +184,29 @@ async function installTemplate(templateId) {
   }
 }
 
+async function applyTemplateUpdate(workflowId, mode = "replace", force = false) {
+  try {
+    const data = await apiFetch(`/api/workflows/${encodeURIComponent(workflowId)}/template-update`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ mode, force }),
+    });
+    if (data?.workflow) {
+      showToast(
+        mode === "copy"
+          ? "Updated template copy created"
+          : "Workflow updated to latest template",
+        "success",
+      );
+      loadWorkflows();
+      return data.workflow;
+    }
+  } catch (err) {
+    showToast(`Template update failed: ${err.message}`, "error");
+  }
+  return null;
+}
+
 async function loadRuns(workflowId) {
   try {
     const url = workflowId
@@ -1570,6 +1593,11 @@ function WorkflowListView() {
           </h3>
           <div style="display: grid; gap: 10px; grid-template-columns: repeat(auto-fill, minmax(300px, 1fr));">
             ${wfs.map(wf => html`
+              ${(() => {
+                const templateState = wf.metadata?.templateState || null;
+                const hasTemplateUpdate = templateState?.updateAvailable === true;
+                const isCustomizedTemplate = templateState?.isCustomized === true;
+                return html`
               <div key=${wf.id} class="wf-card" style="background: var(--color-bg-secondary, #1a1f2e); border-radius: 12px; padding: 14px; border: 1px solid var(--color-border, #2a3040); cursor: pointer; transition: border-color 0.15s;"
                    onClick=${() => {
                      apiFetch("/api/workflows/" + wf.id).then(d => {
@@ -1583,17 +1611,70 @@ function WorkflowListView() {
                   <span class="wf-badge" style="background: ${wf.enabled ? '#10b98130' : '#6b728030'}; color: ${wf.enabled ? '#10b981' : '#6b7280'}; font-size: 10px;">
                     ${wf.enabled ? "Active" : "Paused"}
                   </span>
+                  ${templateState?.templateId && html`
+                    <span class="wf-badge" style="background: #3b82f620; color: #60a5fa; font-size: 10px;">
+                      Template
+                    </span>
+                  `}
+                  ${isCustomizedTemplate && html`
+                    <span class="wf-badge" style="background: #f59e0b20; color: #f59e0b; font-size: 10px;">
+                      Customized
+                    </span>
+                  `}
+                  ${hasTemplateUpdate && html`
+                    <span class="wf-badge" style="background: #ef444420; color: #f87171; font-size: 10px;">
+                      Update Available
+                    </span>
+                  `}
                 </div>
                 ${wf.description && html`
                   <div style="font-size: 12px; color: var(--color-text-secondary, #8b95a5); margin-bottom: 8px; line-height: 1.4;">
                     ${wf.description.slice(0, 120)}${wf.description.length > 120 ? "…" : ""}
                   </div>
                 `}
+                ${templateState?.templateId && html`
+                  <div style="font-size: 11px; color: var(--color-text-secondary, #7f8aa0); margin-bottom: 8px;">
+                    ${templateState.templateName || templateState.templateId}
+                    ${templateState.installedTemplateVersion && templateState.templateVersion && templateState.installedTemplateVersion !== templateState.templateVersion && html`
+                      <span> · v${templateState.installedTemplateVersion} → v${templateState.templateVersion}</span>
+                    `}
+                  </div>
+                `}
                 <div style="display: flex; gap: 8px; align-items: center; font-size: 11px; color: var(--color-text-secondary, #6b7280);">
                   <span>${wf.nodeCount || 0} nodes</span>
                   <span>·</span>
                   <span>${wf.category || "custom"}</span>
                   <div style="flex: 1;"></div>
+                  ${hasTemplateUpdate && html`
+                    <button
+                      class="wf-btn wf-btn-sm"
+                      style="font-size: 11px; border-color: #f59e0b80; color: #f59e0b;"
+                      onClick=${async (e) => {
+                        e.stopPropagation();
+                        if (!isCustomizedTemplate) {
+                          await applyTemplateUpdate(wf.id, "replace", true);
+                          return;
+                        }
+                        const choice = window.prompt(
+                          "Template update available for customized workflow.\nType 'copy' to create an updated copy, or 'replace' to overwrite this workflow.",
+                          "copy",
+                        );
+                        const normalized = String(choice || "").trim().toLowerCase();
+                        if (normalized === "copy") {
+                          await applyTemplateUpdate(wf.id, "copy", false);
+                          return;
+                        }
+                        if (normalized === "replace") {
+                          const ok = window.confirm("Replace this customized workflow with latest template? This cannot be undone.");
+                          if (!ok) return;
+                          await applyTemplateUpdate(wf.id, "replace", true);
+                        }
+                      }}
+                    >
+                      <span class="icon-inline">${resolveIcon("refresh")}</span>
+                      Update
+                    </button>
+                  `}
                   <button
                     class="wf-btn wf-btn-sm"
                     style="font-size: 11px;"
@@ -1624,6 +1705,8 @@ function WorkflowListView() {
                   </button>
                 </div>
               </div>
+            `;
+              })()}
             `)}
           </div>
         </div>

package/ui-server.mjs

@@ -406,6 +406,27 @@ async function getWorkflowEngineModule() {
         if (result.errors.length) {
           console.warn("[workflows] Default template install errors:", result.errors);
         }
+        if (typeof _wfTemplates.reconcileInstalledTemplates === "function") {
+          const reconcile = _wfTemplates.reconcileInstalledTemplates(engine, {
+            autoUpdateUnmodified: true,
+          });
+          if (reconcile.autoUpdated > 0) {
+            console.log(
+              `[workflows] Auto-updated ${reconcile.autoUpdated} unmodified template workflow(s) to latest`,
+            );
+          }
+          if (reconcile.customized.length > 0) {
+            const pending = reconcile.customized.filter((entry) => entry.updateAvailable).length;
+            if (pending > 0) {
+              console.log(
+                `[workflows] ${pending} customized template workflow(s) have updates available`,
+              );
+            }
+          }
+          if (reconcile.errors.length > 0) {
+            console.warn("[workflows] Template reconcile errors:", reconcile.errors);
+          }
+        }
       } catch (err) {
         console.warn("[workflows] Default template install failed:", err.message);
       } finally {
@@ -6258,6 +6279,9 @@ async function handleApi(req, res, url) {
       const wfMod = await getWorkflowEngine();
       if (!wfMod) { jsonResponse(res, 503, { ok: false, error: "Workflow engine not available" }); return; }
       const engine = wfMod.getWorkflowEngine();
+      if (typeof _wfTemplates?.applyWorkflowTemplateState === "function") {
+        _wfTemplates.applyWorkflowTemplateState(body);
+      }
       const saved = await engine.save(body);
       jsonResponse(res, 200, { ok: true, workflow: saved });
     } catch (err) {
@@ -6294,6 +6318,65 @@ async function handleApi(req, res, url) {
     return;
   }
 
+  if (path === "/api/workflows/template-updates") {
+    try {
+      const wfMod = await getWorkflowEngine();
+      if (!wfMod) { jsonResponse(res, 503, { ok: false, error: "Workflow engine not available" }); return; }
+      const engine = wfMod.getWorkflowEngine();
+      if (typeof _wfTemplates?.reconcileInstalledTemplates === "function") {
+        _wfTemplates.reconcileInstalledTemplates(engine, {
+          autoUpdateUnmodified: true,
+        });
+      }
+      const updates = engine
+        .list()
+        .map((wf) => {
+          const state = wf.metadata?.templateState || null;
+          if (!state?.templateId) return null;
+          return {
+            workflowId: wf.id,
+            workflowName: wf.name,
+            templateId: state.templateId,
+            templateName: state.templateName || state.templateId,
+            updateAvailable: state.updateAvailable === true,
+            isCustomized: state.isCustomized === true,
+            templateVersion: state.templateVersion || null,
+            installedTemplateVersion: state.installedTemplateVersion || null,
+          };
+        })
+        .filter(Boolean);
+      jsonResponse(res, 200, { ok: true, updates });
+    } catch (err) {
+      jsonResponse(res, 500, { ok: false, error: err.message });
+    }
+    return;
+  }
+
+  if (path.startsWith("/api/workflows/") && path.endsWith("/template-update")) {
+    try {
+      const wfMod = await getWorkflowEngine();
+      if (!wfMod) { jsonResponse(res, 503, { ok: false, error: "Workflow engine not available" }); return; }
+      const engine = wfMod.getWorkflowEngine();
+      const workflowId = decodeURIComponent(path.split("/")[3] || "");
+      if (!workflowId) {
+        jsonResponse(res, 400, { ok: false, error: "Missing workflow id" });
+        return;
+      }
+      const body = await readJsonBody(req).catch(() => ({}));
+      const mode = String(body?.mode || "replace").toLowerCase();
+      const force = body?.force === true;
+      if (typeof _wfTemplates?.updateWorkflowFromTemplate !== "function") {
+        jsonResponse(res, 503, { ok: false, error: "Template update service unavailable" });
+        return;
+      }
+      const workflow = _wfTemplates.updateWorkflowFromTemplate(engine, workflowId, { mode, force });
+      jsonResponse(res, 200, { ok: true, workflow });
+    } catch (err) {
+      jsonResponse(res, 500, { ok: false, error: err.message });
+    }
+    return;
+  }
+
   if (path === "/api/workflows/node-types") {
     try {
       const wfMod = await getWorkflowEngine();
@@ -7436,7 +7519,16 @@ async function handleApi(req, res, url) {
             const ev = event || err;
             if (!ev) return;
             try {
-              tracker.recordEvent(sessionId, ev);
+              if (typeof ev === "string") {
+                tracker.recordEvent(sessionId, {
+                  role: "system",
+                  type: "system",
+                  content: ev,
+                  timestamp: new Date().toISOString(),
+                });
+              } else {
+                tracker.recordEvent(sessionId, ev);
+              }
             } catch {
               /* best-effort — never crash the agent loop */
             }
@@ -7450,6 +7542,8 @@ async function handleApi(req, res, url) {
             sessionType: "primary",
             mode: messageMode,
             model: messageModel,
+            persistent: true,
+            sendRawEvents: true,
             attachments,
             attachmentsAppended,
             onEvent: streamOnEvent,

package/workflow-templates/github.mjs

@@ -747,7 +747,7 @@ export const BOSUN_PR_WATCHDOG_TEMPLATE = {
         "    } else if(hasPend){",
         "      pending.push(pr.number);",
         "    } else if(checks.length>0&&!hasFixLabel){",
-        "      // CI all-passing, no conflicts, not draft — a review candidate",
+        "      /* CI all-passing, no conflicts, not draft — a review candidate */",
         "      readyCandidates.push({n:pr.number,branch:pr.headRefName,base:pr.baseRefName,url:pr.url,title:pr.title});",
         "    }",
         "  }",

package/workflow-templates.mjs

@@ -29,7 +29,7 @@
  *   listTemplates()        — List all available templates
  */
 
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 
 // ── Re-export helpers for external consumers ────────────────────────────────
 export { node, edge, resetLayout } from "./workflow-templates/_helpers.mjs";
@@ -176,6 +176,216 @@ export const WORKFLOW_TEMPLATES = Object.freeze([
 const _TEMPLATE_BY_ID = new Map(
   WORKFLOW_TEMPLATES.map((template) => [template.id, template]),
 );
+const TEMPLATE_STATE_VERSION = 1;
+
+function stableNormalize(value) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => stableNormalize(entry));
+  }
+  if (value && typeof value === "object") {
+    const normalized = {};
+    for (const key of Object.keys(value).sort()) {
+      normalized[key] = stableNormalize(value[key]);
+    }
+    return normalized;
+  }
+  return value;
+}
+
+function stableStringify(value) {
+  return JSON.stringify(stableNormalize(value));
+}
+
+function hashContent(value) {
+  return createHash("sha256").update(stableStringify(value)).digest("hex");
+}
+
+function toWorkflowFingerprintPayload(def = {}) {
+  return {
+    name: def.name || "",
+    description: def.description || "",
+    category: def.category || "custom",
+    trigger: def.trigger || "",
+    variables: def.variables || {},
+    nodes: def.nodes || [],
+    edges: def.edges || [],
+  };
+}
+
+export function computeWorkflowFingerprint(def = {}) {
+  return hashContent(toWorkflowFingerprintPayload(def));
+}
+
+function cloneTemplateDefinition(template) {
+  return JSON.parse(JSON.stringify(template));
+}
+
+function getTemplateVersion(templateId) {
+  const template = getTemplate(templateId);
+  if (!template) return null;
+  return computeWorkflowFingerprint(template).slice(0, 12);
+}
+
+function deriveTemplateState(def, template) {
+  const nowIso = new Date().toISOString();
+  const currentFingerprint = computeWorkflowFingerprint(def);
+  const templateFingerprint = computeWorkflowFingerprint(template);
+  const previousState = def?.metadata?.templateState || {};
+
+  const installedTemplateFingerprint = typeof previousState.installedTemplateFingerprint === "string"
+    ? previousState.installedTemplateFingerprint
+    : (currentFingerprint === templateFingerprint ? templateFingerprint : null);
+
+  const installedFingerprint = typeof previousState.installedFingerprint === "string"
+    ? previousState.installedFingerprint
+    : currentFingerprint;
+
+  const isCustomized = currentFingerprint !== installedFingerprint;
+  const updateAvailable = installedTemplateFingerprint
+    ? installedTemplateFingerprint !== templateFingerprint
+    : false;
+
+  return {
+    stateVersion: TEMPLATE_STATE_VERSION,
+    templateId: template.id,
+    templateName: template.name,
+    templateVersion: templateFingerprint.slice(0, 12),
+    templateFingerprint,
+    installedTemplateFingerprint,
+    installedTemplateVersion: installedTemplateFingerprint
+      ? installedTemplateFingerprint.slice(0, 12)
+      : null,
+    installedFingerprint,
+    currentFingerprint,
+    isCustomized,
+    updateAvailable,
+    refreshedAt: nowIso,
+  };
+}
+
+export function applyWorkflowTemplateState(def = {}) {
+  if (!def || typeof def !== "object") return def;
+  const templateId = String(def?.metadata?.installedFrom || "").trim();
+  if (!templateId) return def;
+  const template = getTemplate(templateId);
+  if (!template) return def;
+  if (!def.metadata || typeof def.metadata !== "object") def.metadata = {};
+  def.metadata.templateState = deriveTemplateState(def, template);
+  return def;
+}
+
+function makeUpdatedWorkflowFromTemplate(existing, template, mode = "replace") {
+  const templateClone = cloneTemplateDefinition(template);
+  const nowIso = new Date().toISOString();
+  const mergedVariables = {
+    ...(templateClone.variables || {}),
+    ...(existing.variables || {}),
+  };
+  const next = {
+    ...templateClone,
+    id: mode === "copy" ? randomUUID() : existing.id,
+    name: mode === "copy" ? `${existing.name} (Updated)` : existing.name,
+    enabled: existing.enabled !== false,
+    variables: mergedVariables,
+    metadata: {
+      ...(existing.metadata || {}),
+      ...(templateClone.metadata || {}),
+      installedFrom: template.id,
+      templateUpdatedAt: nowIso,
+    },
+  };
+  delete next.metadata.templateState;
+  if (mode === "copy") {
+    next.metadata.createdAt = nowIso;
+    next.metadata.updatedAt = nowIso;
+  }
+  return applyWorkflowTemplateState(next);
+}
+
+export function updateWorkflowFromTemplate(engine, workflowId, opts = {}) {
+  const mode = String(opts.mode || "replace").toLowerCase();
+  if (!["replace", "copy"].includes(mode)) {
+    throw new Error(`Unsupported template update mode "${mode}"`);
+  }
+  const existing = engine.get(workflowId);
+  if (!existing) throw new Error(`Workflow "${workflowId}" not found`);
+  const templateId = String(existing?.metadata?.installedFrom || "").trim();
+  if (!templateId) throw new Error(`Workflow "${workflowId}" is not template-backed`);
+  const template = getTemplate(templateId);
+  if (!template) throw new Error(`Template "${templateId}" not found`);
+
+  const hydrated = applyWorkflowTemplateState(existing);
+  if (mode === "replace" && hydrated?.metadata?.templateState?.isCustomized && opts.force !== true) {
+    throw new Error("Workflow has custom changes; pass force=true to replace it");
+  }
+
+  const next = makeUpdatedWorkflowFromTemplate(hydrated, template, mode);
+  return engine.save(next);
+}
+
+export function reconcileInstalledTemplates(engine, opts = {}) {
+  const autoUpdateUnmodified = opts.autoUpdateUnmodified !== false;
+  const workflows = engine.list();
+  const result = {
+    scanned: 0,
+    metadataUpdated: 0,
+    autoUpdated: 0,
+    updateAvailable: [],
+    customized: [],
+    updatedWorkflowIds: [],
+    errors: [],
+  };
+
+  for (const summary of workflows) {
+    const wfId = summary?.id;
+    if (!wfId) continue;
+    const def = engine.get(wfId);
+    if (!def?.metadata?.installedFrom) continue;
+    result.scanned += 1;
+
+    try {
+      const before = stableStringify(def.metadata?.templateState || null);
+      applyWorkflowTemplateState(def);
+      const state = def.metadata?.templateState || null;
+      const after = stableStringify(state);
+      if (before !== after) {
+        engine.save(def);
+        result.metadataUpdated += 1;
+      }
+
+      if (!state) continue;
+      if (state.isCustomized) {
+        result.customized.push({
+          workflowId: def.id,
+          name: def.name,
+          templateId: state.templateId,
+          updateAvailable: state.updateAvailable === true,
+        });
+      }
+      if (state.updateAvailable === true) {
+        result.updateAvailable.push({
+          workflowId: def.id,
+          name: def.name,
+          templateId: state.templateId,
+          isCustomized: state.isCustomized === true,
+        });
+      }
+
+      if (autoUpdateUnmodified && state.updateAvailable === true && state.isCustomized !== true) {
+        const saved = updateWorkflowFromTemplate(engine, def.id, { mode: "replace", force: true });
+        result.autoUpdated += 1;
+        result.updatedWorkflowIds.push(saved.id);
+      }
+    } catch (err) {
+      result.errors.push({
+        workflowId: wfId,
+        error: err.message,
+      });
+    }
+  }
+
+  return result;
+}
 
 /**
  * Setup workflow profiles used by `bosun --setup`.
@@ -287,6 +497,7 @@ export function getTemplate(id) {
 export function listTemplates() {
   return WORKFLOW_TEMPLATES.map((t) => {
     const cat = TEMPLATE_CATEGORIES[t.category] || TEMPLATE_CATEGORIES.custom;
+    const fingerprint = computeWorkflowFingerprint(t);
     return {
       id: t.id,
       name: t.name,
@@ -298,6 +509,8 @@ export function listTemplates() {
       tags: t.metadata?.tags || [],
       nodeCount: t.nodes?.length || 0,
       edgeCount: t.edges?.length || 0,
+      version: fingerprint.slice(0, 12),
+      fingerprint,
       replaces: t.metadata?.replaces || null,
       recommended: t.recommended === true,
       enabled: t.enabled !== false,
@@ -384,7 +597,7 @@ export function installTemplate(templateId, engine, overrides = {}) {
   }
 
   // Deep clone
-  const def = JSON.parse(JSON.stringify(template));
+  const def = cloneTemplateDefinition(template);
   def.id = randomUUID(); // New unique ID
   def.metadata = {
     ...def.metadata,
@@ -398,6 +611,7 @@ export function installTemplate(templateId, engine, overrides = {}) {
     def.variables = { ...def.variables, ...overrides };
   }
 
+  applyWorkflowTemplateState(def);
   return engine.save(def);
 }