@percena/weft 0.4.0-next.1 → 0.4.0-next.3

package/dist/automations.cjs

@@ -1,3044 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/automations.ts
-var automations_exports = {};
-__export(automations_exports, {
-  AGENT_EVENTS: () => AGENT_EVENTS,
-  APP_EVENTS: () => APP_EVENTS,
-  AUTOMATIONS_CONFIG_FILE: () => AUTOMATIONS_CONFIG_FILE,
-  AUTOMATIONS_HISTORY_FILE: () => AUTOMATIONS_HISTORY_FILE,
-  AUTOMATIONS_RETRY_QUEUE_FILE: () => AUTOMATIONS_RETRY_QUEUE_FILE,
-  AUTOMATION_HISTORY_MAX_ENTRIES: () => AUTOMATION_HISTORY_MAX_ENTRIES,
-  AUTOMATION_HISTORY_MAX_RUNS_PER_MATCHER: () => AUTOMATION_HISTORY_MAX_RUNS_PER_MATCHER,
-  AutomationConditionSchema: () => AutomationConditionSchema,
-  AutomationEventLogger: () => AutomationEventLogger,
-  AutomationSystem: () => AutomationSystem,
-  AutomationsConfigSchema: () => AutomationsConfigSchema,
-  EventLogHandler: () => EventLogHandler,
-  HISTORY_FIELD_MAX_LENGTH: () => HISTORY_FIELD_MAX_LENGTH,
-  PromptHandler: () => PromptHandler,
-  RetryScheduler: () => RetryScheduler,
-  StateConditionSchema: () => StateConditionSchema,
-  TimeConditionSchema: () => TimeConditionSchema,
-  VALID_EVENTS: () => VALID_EVENTS,
-  WebhookHandler: () => WebhookHandler,
-  WorkspaceEventBus: () => WorkspaceEventBus,
-  appendAutomationHistoryEntry: () => appendAutomationHistoryEntry,
-  automationHistoryInputForPromptResult: () => automationHistoryInputForPromptResult,
-  buildEnvFromSdkInput: () => buildEnvFromSdkInput,
-  compactAutomationHistory: () => compactAutomationHistory,
-  compactAutomationHistorySync: () => compactAutomationHistorySync,
-  createAutomationRuntimeGuard: () => createAutomationRuntimeGuard,
-  createAutomationSchedulerHost: () => createAutomationSchedulerHost,
-  createAutomationTimelineBridge: () => createAutomationTimelineBridge,
-  createAutomationsConfigDoctorReport: () => createAutomationsConfigDoctorReport,
-  createInMemoryAutomationHistoryStore: () => createInMemoryAutomationHistoryStore,
-  createPromptHistoryEntry: () => createPromptHistoryEntry,
-  createRuntimeAutomationBridge: () => createRuntimeAutomationBridge,
-  createWebhookHistoryEntry: () => createWebhookHistoryEntry,
-  evaluateAutoLabels: () => evaluateAutoLabels,
-  evaluateConditions: () => evaluateConditions,
-  executeAutomationPrompt: () => executeAutomationPrompt,
-  executeWebhookRequest: () => executeWebhookRequest,
-  executeWithRetry: () => executeWithRetry,
-  extractLabelId: () => extractLabelId,
-  generateShortId: () => generateShortId,
-  loadAutomationsConfig: () => loadAutomationsConfig,
-  matchesCron: () => matchesCron,
-  normalizeNumberValue: () => normalizeNumberValue,
-  parsePromptReferences: () => parsePromptReferences,
-  projectTimelineEnvelopeToAutomationInput: () => projectTimelineEnvelopeToAutomationInput,
-  resolveAutomationsConfigPath: () => resolveAutomationsConfigPath,
-  sanitizeForShell: () => sanitizeForShell,
-  saveAutomationsConfig: () => saveAutomationsConfig,
-  validateAutoLabelPattern: () => validateAutoLabelPattern,
-  validateAutomations: () => validateAutomations,
-  validateAutomationsConfig: () => validateAutomationsConfig,
-  validateAutomationsContent: () => validateAutomationsContent,
-  zodErrorToIssues: () => zodErrorToIssues
-});
-module.exports = __toCommonJS(automations_exports);
-
-// ../packages/automations/dist/index.js
-var import_fs = require("fs");
-var import_crypto = require("crypto");
-var import_path = require("path");
-var import_zod = require("zod");
-
-// ../packages/core/dist/index.js
-var THINKING_LEVEL_IDS = [
-  "off",
-  "low",
-  "medium",
-  "high",
-  "xhigh",
-  "max"
-];
-function isValidThinkingLevel(value) {
-  return typeof value === "string" && THINKING_LEVEL_IDS.includes(value);
-}
-function normalizeThinkingLevel(value) {
-  if (value === "think") return "medium";
-  if (isValidThinkingLevel(value)) return value;
-  return void 0;
-}
-
-// ../packages/automations/dist/index.js
-var import_croner = require("croner");
-var import_croner2 = require("croner");
-var import_promises = require("fs/promises");
-var import_path2 = require("path");
-var import_promises2 = require("fs/promises");
-var import_fs2 = require("fs");
-var import_path3 = require("path");
-var import_fs3 = require("fs");
-var import_fs4 = require("fs");
-var APP_EVENTS = [
-  "LabelAdd",
-  "LabelRemove",
-  "LabelConfigChange",
-  "PermissionModeChange",
-  "FlagChange",
-  "SessionStatusChange",
-  "SchedulerTick"
-];
-var AGENT_EVENTS = [
-  "PreToolUse",
-  "PostToolUse",
-  "PostToolUseFailure",
-  "Notification",
-  "UserPromptSubmit",
-  "SessionStart",
-  "SessionEnd",
-  "Stop",
-  "SubagentStart",
-  "SubagentStop",
-  "PreCompact",
-  "PermissionRequest",
-  "Setup"
-];
-var AUTOMATIONS_CONFIG_FILE = "automations.json";
-var AUTOMATIONS_HISTORY_FILE = "automations-history.jsonl";
-var AUTOMATIONS_RETRY_QUEUE_FILE = "automations-retry-queue.jsonl";
-var DEFAULT_WEBHOOK_METHOD = "POST";
-var HISTORY_FIELD_MAX_LENGTH = 2e3;
-var AUTOMATION_HISTORY_MAX_RUNS_PER_MATCHER = 20;
-var AUTOMATION_HISTORY_MAX_ENTRIES = 1e3;
-function generateShortId() {
-  return (0, import_crypto.randomBytes)(3).toString("hex");
-}
-function resolveAutomationsConfigPath(workspaceRoot) {
-  return (0, import_path.join)(workspaceRoot, AUTOMATIONS_CONFIG_FILE);
-}
-var ThinkingLevelInputSchema = import_zod.z.enum(["off", "low", "medium", "high", "xhigh", "max", "think"]).transform((value) => normalizeThinkingLevel(value)).optional();
-var PromptActionSchema = import_zod.z.object({
-  type: import_zod.z.literal("prompt"),
-  prompt: import_zod.z.string().min(1, "Prompt cannot be empty"),
-  llmConnection: import_zod.z.string().min(1).optional(),
-  model: import_zod.z.string().min(1).optional(),
-  thinkingLevel: ThinkingLevelInputSchema
-});
-var WebhookActionSchema = import_zod.z.object({
-  type: import_zod.z.literal("webhook"),
-  url: import_zod.z.string().min(1, "URL cannot be empty").refine(
-    (url) => {
-      if (url.includes("$")) return true;
-      try {
-        const parsed = new URL(url);
-        return parsed.protocol === "http:" || parsed.protocol === "https:";
-      } catch {
-        return false;
-      }
-    },
-    "URL must be a valid http/https URL or contain $VAR templates"
-  ),
-  method: import_zod.z.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]).optional(),
-  headers: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).optional(),
-  bodyFormat: import_zod.z.enum(["json", "form", "raw"]).optional(),
-  body: import_zod.z.unknown().optional(),
-  captureResponse: import_zod.z.boolean().optional(),
-  auth: import_zod.z.union([
-    import_zod.z.object({
-      type: import_zod.z.literal("basic"),
-      username: import_zod.z.string().min(1),
-      password: import_zod.z.string()
-    }),
-    import_zod.z.object({
-      type: import_zod.z.literal("bearer"),
-      token: import_zod.z.string().min(1)
-    })
-  ]).optional()
-});
-var ActionDefinitionSchema = import_zod.z.union([
-  PromptActionSchema,
-  WebhookActionSchema,
-  import_zod.z.object({ type: import_zod.z.string() }).passthrough()
-]);
-var VALID_WEEKDAYS = ["mon", "tue", "wed", "thu", "fri", "sat", "sun"];
-var TimeConditionSchema = import_zod.z.object({
-  condition: import_zod.z.literal("time"),
-  after: import_zod.z.string().regex(/^\d{2}:\d{2}$/, "Must be HH:MM format").optional(),
-  before: import_zod.z.string().regex(/^\d{2}:\d{2}$/, "Must be HH:MM format").optional(),
-  weekday: import_zod.z.array(import_zod.z.enum(VALID_WEEKDAYS)).optional(),
-  timezone: import_zod.z.string().optional()
-});
-var StateConditionSchema = import_zod.z.object({
-  condition: import_zod.z.literal("state"),
-  field: import_zod.z.string().min(1, "Field name cannot be empty"),
-  value: import_zod.z.unknown().optional(),
-  from: import_zod.z.unknown().optional(),
-  to: import_zod.z.unknown().optional(),
-  contains: import_zod.z.string().optional(),
-  not_value: import_zod.z.unknown().optional()
-}).superRefine((data, ctx) => {
-  const hasValue = data.value !== void 0;
-  const hasFromOrTo = data.from !== void 0 || data.to !== void 0;
-  const hasContains = data.contains !== void 0;
-  const hasNotValue = data.not_value !== void 0;
-  const operatorCount = (hasValue ? 1 : 0) + (hasFromOrTo ? 1 : 0) + (hasContains ? 1 : 0) + (hasNotValue ? 1 : 0);
-  if (operatorCount === 0) {
-    ctx.addIssue({
-      code: import_zod.z.ZodIssueCode.custom,
-      message: "State condition must have at least one operator (value, from/to, contains, or not_value)",
-      path: ["field"]
-    });
-    return;
-  }
-  if (operatorCount > 1) {
-    ctx.addIssue({
-      code: import_zod.z.ZodIssueCode.custom,
-      message: "State condition must use exactly one operator group (value, from/to, contains, or not_value)",
-      path: ["field"]
-    });
-  }
-});
-var AutomationConditionSchema = import_zod.z.lazy(
-  () => import_zod.z.union([
-    TimeConditionSchema,
-    StateConditionSchema,
-    import_zod.z.object({
-      condition: import_zod.z.enum(["and", "or", "not"]),
-      conditions: import_zod.z.array(AutomationConditionSchema).min(1, "Logical condition must have at least one sub-condition")
-    })
-  ])
-);
-var AutomationMatcherSchema = import_zod.z.object({
-  id: import_zod.z.string().optional(),
-  name: import_zod.z.string().optional(),
-  matcher: import_zod.z.string().optional(),
-  cron: import_zod.z.string().optional(),
-  timezone: import_zod.z.string().optional(),
-  permissionMode: import_zod.z.enum(["safe", "ask", "allow-all"]).optional(),
-  labels: import_zod.z.array(import_zod.z.string()).optional(),
-  enabled: import_zod.z.boolean().optional(),
-  conditions: import_zod.z.array(AutomationConditionSchema).optional(),
-  // Telegram forum-topic name (1–128 chars). Silently ignored at runtime when
-  // no supergroup is paired or the Telegram adapter is not connected.
-  telegramTopic: import_zod.z.string().min(1).max(128).optional(),
-  actions: import_zod.z.array(ActionDefinitionSchema).min(1, "At least one action required")
-});
-var DEPRECATED_EVENT_ALIASES = {
-  "TodoStateChange": "SessionStatusChange"
-};
-var VALID_EVENTS = [
-  ...APP_EVENTS,
-  ...AGENT_EVENTS,
-  ...Object.keys(DEPRECATED_EVENT_ALIASES)
-];
-var AutomationsConfigSchema = import_zod.z.object({
-  version: import_zod.z.number().optional(),
-  automations: import_zod.z.record(import_zod.z.string(), import_zod.z.array(AutomationMatcherSchema)).optional()
-}).transform((data) => {
-  const automations = data.automations ?? {};
-  const validAutomations = {};
-  for (const [event, matchers] of Object.entries(automations)) {
-    if (VALID_EVENTS.includes(event)) {
-      const canonical = DEPRECATED_EVENT_ALIASES[event];
-      if (canonical) {
-        validAutomations[canonical] = [...validAutomations[canonical] ?? [], ...matchers];
-      } else {
-        validAutomations[event] = [...validAutomations[event] ?? [], ...matchers];
-      }
-    }
-  }
-  return { version: data.version, automations: validAutomations };
-});
-function zodErrorToIssues(error, file) {
-  return error.issues.map((issue) => ({
-    file,
-    path: issue.path.join(".") || "root",
-    message: issue.message,
-    severity: "error"
-  }));
-}
-function isValidLabelId(_workspaceRoot, _labelId) {
-  return true;
-}
-function extractLabelId(label) {
-  const separatorIndex = label.indexOf("::");
-  if (separatorIndex !== -1) {
-    return label.slice(0, separatorIndex);
-  }
-  return label;
-}
-function getLlmConnection(_slug) {
-  return null;
-}
-function getDefaultModelsForConnection(_providerType, _piAuthProvider) {
-  return [];
-}
-var MAX_CONDITION_DEPTH_EXCLUSIVE = 8;
-var CONDITION_DEPTH_WARNING_THRESHOLD = 4;
-function validateAutomationsConfig(content) {
-  const result = AutomationsConfigSchema.safeParse(content);
-  if (!result.success) {
-    const errors = result.error.issues.map((issue) => {
-      const path = issue.path.join(".");
-      return path ? `${path}: ${issue.message}` : issue.message;
-    });
-    return { valid: false, errors, config: null };
-  }
-  const schemaConfig = result.data;
-  const semanticErrors = [];
-  runMatcherSemanticValidations(schemaConfig, AUTOMATIONS_CONFIG_FILE, semanticErrors, []);
-  if (semanticErrors.length > 0) {
-    const errors = semanticErrors.map((issue) => issue.path ? `${issue.path}: ${issue.message}` : issue.message);
-    return { valid: false, errors, config: null };
-  }
-  return { valid: true, errors: [], config: schemaConfig };
-}
-function runMatcherSemanticValidations(config, file, errors, warnings) {
-  for (const [event, matchers] of Object.entries(config.automations)) {
-    if (!matchers) continue;
-    for (let i = 0; i < matchers.length; i++) {
-      const matcher = matchers[i];
-      if (!matcher) continue;
-      if (matcher.permissionMode === "allow-all") {
-        warnings.push({
-          file,
-          path: `automations.${event}[${i}].permissionMode`,
-          message: 'permissionMode "allow-all" bypasses all security checks \u2014 use with caution',
-          severity: "warning",
-          suggestion: 'Consider using "safe" or "ask" permission mode instead'
-        });
-      }
-      if (matcher.matcher) {
-        const MAX_REGEX_LENGTH = 500;
-        if (matcher.matcher.length > MAX_REGEX_LENGTH) {
-          errors.push({
-            file,
-            path: `automations.${event}[${i}].matcher`,
-            message: `Regex pattern too long (${matcher.matcher.length} chars, max ${MAX_REGEX_LENGTH})`,
-            severity: "error",
-            suggestion: "Simplify the regex pattern or split into multiple matchers"
-          });
-        } else {
-          try {
-            new RegExp(matcher.matcher);
-            const nestedQuantifiers = /\([^)]*[+*][^)]*\)[+*{]/;
-            const riskyPatterns = /(\.\*){2,}|(\.\+){2,}|\([^)]*\|[^)]*\)[+*{]/;
-            if (nestedQuantifiers.test(matcher.matcher) || riskyPatterns.test(matcher.matcher)) {
-              errors.push({
-                file,
-                path: `automations.${event}[${i}].matcher`,
-                message: "Regex pattern rejected: potential catastrophic backtracking (ReDoS)",
-                severity: "error",
-                suggestion: "Avoid nested quantifiers like (a+)+, (.*)+, (.+)*, ([a-z]+)+, and repeated alternation like (a|a)+"
-              });
-            }
-          } catch (e) {
-            errors.push({
-              file,
-              path: `automations.${event}[${i}].matcher`,
-              message: `Invalid regex pattern: ${e instanceof Error ? e.message : "Unknown error"}`,
-              severity: "error",
-              suggestion: "Fix the regex pattern or remove the matcher to match all events"
-            });
-          }
-        }
-      }
-      if (matcher.cron) {
-        try {
-          new import_croner.Cron(matcher.cron);
-        } catch (e) {
-          errors.push({
-            file,
-            path: `automations.${event}[${i}].cron`,
-            message: `Invalid cron expression: ${e instanceof Error ? e.message : "Unknown error"}`,
-            severity: "error",
-            suggestion: "Use standard 5-field cron format: minute hour day-of-month month day-of-week"
-          });
-        }
-      }
-      if (matcher.timezone) {
-        try {
-          Intl.DateTimeFormat(void 0, { timeZone: matcher.timezone });
-        } catch {
-          errors.push({
-            file,
-            path: `automations.${event}[${i}].timezone`,
-            message: `Invalid timezone: ${matcher.timezone}`,
-            severity: "error",
-            suggestion: 'Use IANA timezone format like "Europe/Budapest" or "America/New_York"'
-          });
-        }
-      }
-      if (matcher.actions) {
-        for (let j = 0; j < matcher.actions.length; j++) {
-          const action = matcher.actions[j];
-          if (action && typeof action === "object" && "type" in action && action.type === "webhook" && "url" in action && typeof action.url === "string" && action.url.includes("$")) {
-            warnings.push({
-              file,
-              path: `automations.${event}[${i}].actions[${j}].url`,
-              message: "Webhook URL contains variable templates \u2014 will be validated at runtime after expansion",
-              severity: "warning",
-              suggestion: "Ensure the referenced WEFT_WH_* variables are set in your shell profile"
-            });
-          }
-        }
-      }
-      if (matcher.cron && event !== "SchedulerTick") {
-        warnings.push({
-          file,
-          path: `automations.${event}[${i}].cron`,
-          message: "Cron expressions are only used for SchedulerTick events",
-          severity: "warning",
-          suggestion: "Move this automation to the SchedulerTick event or use matcher instead"
-        });
-      }
-      if (matcher.conditions && Array.isArray(matcher.conditions)) {
-        validateConditionsArray(matcher.conditions, `automations.${event}[${i}].conditions`, event, file, errors, warnings, 0);
-      }
-    }
-  }
-}
-function validateAutomationsContent(jsonString, fileName) {
-  const file = fileName ?? AUTOMATIONS_CONFIG_FILE;
-  const errors = [];
-  const warnings = [];
-  let content;
-  try {
-    content = JSON.parse(jsonString);
-  } catch (e) {
-    return {
-      valid: false,
-      errors: [{
-        file,
-        path: "",
-        message: `Invalid JSON: ${e instanceof Error ? e.message : "Unknown error"}`,
-        severity: "error"
-      }],
-      warnings: []
-    };
-  }
-  const result = AutomationsConfigSchema.safeParse(content);
-  if (!result.success) {
-    errors.push(...zodErrorToIssues(result.error, file));
-    return { valid: false, errors, warnings };
-  }
-  const config = result.data;
-  const matcherCount = Object.values(config.automations).reduce(
-    (sum, matchers) => sum + (matchers?.length ?? 0),
-    0
-  );
-  if (matcherCount === 0) {
-    warnings.push({
-      file,
-      path: "automations",
-      message: "No automations configured",
-      severity: "warning",
-      suggestion: "Add automation definitions under event names like SessionStatusChange, LabelAdd, etc."
-    });
-  }
-  try {
-    const rawConfig = JSON.parse(jsonString);
-    if (rawConfig.automations) {
-      for (const event of Object.keys(rawConfig.automations)) {
-        const canonical = DEPRECATED_EVENT_ALIASES[event];
-        if (canonical) {
-          warnings.push({
-            file,
-            path: `automations.${event}`,
-            message: `Event '${event}' has been renamed to '${canonical}'. The old name still works but is deprecated.`,
-            severity: "warning",
-            suggestion: `Rename '${event}' to '${canonical}' in your config`
-          });
-        }
-      }
-    }
-  } catch {
-  }
-  runMatcherSemanticValidations(config, file, errors, warnings);
-  return {
-    valid: errors.length === 0,
-    errors,
-    warnings
-  };
-}
-function createAutomationsConfigDoctorReport(jsonString, fileName) {
-  const diagnostics = validateAutomationsContent(jsonString, fileName);
-  const summary = summarizeAutomationsConfig(jsonString);
-  return {
-    domain: "automations",
-    valid: diagnostics.valid,
-    errors: diagnostics.errors,
-    warnings: diagnostics.warnings,
-    summary
-  };
-}
-function validateAutomations(workspaceRoot) {
-  const configPath = resolveAutomationsConfigPath(workspaceRoot);
-  const file = "automations.json";
-  if (!(0, import_fs.existsSync)(configPath)) {
-    return {
-      valid: true,
-      errors: [],
-      warnings: [{
-        file,
-        path: "",
-        message: "No automations configuration found (no automations configured)",
-        severity: "warning"
-      }]
-    };
-  }
-  let raw;
-  try {
-    raw = (0, import_fs.readFileSync)(configPath, "utf-8");
-  } catch (e) {
-    return {
-      valid: false,
-      errors: [{
-        file,
-        path: "",
-        message: `Cannot read file: ${e instanceof Error ? e.message : "Unknown error"}`,
-        severity: "error"
-      }],
-      warnings: []
-    };
-  }
-  let content;
-  try {
-    content = JSON.parse(raw);
-  } catch (e) {
-    return {
-      valid: false,
-      errors: [{
-        file,
-        path: "",
-        message: `Invalid JSON: ${e instanceof Error ? e.message : "Unknown error"}`,
-        severity: "error"
-      }],
-      warnings: []
-    };
-  }
-  const contentResult = validateAutomationsContent(raw);
-  if (!contentResult.valid) {
-    return contentResult;
-  }
-  const errors = [];
-  const warnings = [...contentResult.warnings];
-  try {
-    const config = content;
-    const labelEntries = config.automations;
-    if (labelEntries) {
-      for (const [event, matchers] of Object.entries(labelEntries)) {
-        if (!matchers) continue;
-        for (let i = 0; i < matchers.length; i++) {
-          const matcher = matchers[i];
-          if (matcher?.labels) {
-            for (const label of matcher.labels) {
-              const labelId = extractLabelId(label);
-              if (!isValidLabelId(workspaceRoot, labelId)) {
-                warnings.push({
-                  file,
-                  path: `automations.${event}[${i}].labels`,
-                  message: `Label "${labelId}" does not exist in workspace`,
-                  severity: "warning",
-                  suggestion: `Create this label in labels/config.json or use an existing label ID`
-                });
-              }
-            }
-          }
-          const actions = matcher?.actions;
-          if (actions) {
-            for (const action of actions) {
-              if (action.type !== "prompt") continue;
-              if (action.llmConnection) {
-                const connection = getLlmConnection(action.llmConnection);
-                if (!connection) {
-                  errors.push({
-                    file,
-                    path: `automations.${event}[${i}].actions`,
-                    message: `LLM connection "${action.llmConnection}" not found in config`,
-                    severity: "error",
-                    suggestion: "Check the connection slug in AI Settings or config.json"
-                  });
-                } else if (action.model) {
-                  const availableModels = connection.models ?? getDefaultModelsForConnection(connection.providerType, connection.piAuthProvider);
-                  const modelIds = availableModels.map((m) => typeof m === "string" ? m : m.id);
-                  const modelValue = action.model;
-                  const isAvailable = modelIds.some(
-                    (id) => id === modelValue || id.endsWith(`/${modelValue}`) || // Also match short aliases: "haiku" → any id containing "haiku", "sonnet" → "sonnet", etc.
-                    id.toLowerCase().includes(modelValue.toLowerCase())
-                  );
-                  if (!isAvailable) {
-                    warnings.push({
-                      file,
-                      path: `automations.${event}[${i}].actions`,
-                      message: `Model "${modelValue}" may not be available on connection "${action.llmConnection}" (${connection.providerType})`,
-                      severity: "warning",
-                      suggestion: `Available models: ${modelIds.slice(0, 5).join(", ")}${modelIds.length > 5 ? `, ... (${modelIds.length} total)` : ""}`
-                    });
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  } catch {
-  }
-  const allErrors = [...contentResult.errors, ...errors];
-  return {
-    valid: allErrors.length === 0,
-    errors: allErrors,
-    warnings
-  };
-}
-function summarizeAutomationsConfig(jsonString) {
-  try {
-    const parsed = JSON.parse(jsonString);
-    let matcherCount = 0;
-    let actionCount = 0;
-    for (const matchers of Object.values(parsed.automations ?? {})) {
-      if (!Array.isArray(matchers)) continue;
-      matcherCount += matchers.length;
-      actionCount += matchers.reduce((sum, matcher) => {
-        const actions = matcher && typeof matcher === "object" ? matcher.actions : void 0;
-        return sum + (Array.isArray(actions) ? actions.length : 0);
-      }, 0);
-    }
-    return { matcherCount, actionCount };
-  } catch {
-    return { matcherCount: 0, actionCount: 0 };
-  }
-}
-var VALID_WEEKDAYS2 = /* @__PURE__ */ new Set(["mon", "tue", "wed", "thu", "fri", "sat", "sun"]);
-var HH_MM_RE = /^\d{2}:\d{2}$/;
-var TRANSITION_EVENTS = /* @__PURE__ */ new Set(["PermissionModeChange", "SessionStatusChange"]);
-function validateConditionsArray(conditions, basePath, event, file, errors, warnings, depth) {
-  if (depth > CONDITION_DEPTH_WARNING_THRESHOLD) {
-    warnings.push({
-      file,
-      path: basePath,
-      message: `Condition nesting depth ${depth} \u2014 consider simplifying`,
-      severity: "warning"
-    });
-  }
-  if (depth >= MAX_CONDITION_DEPTH_EXCLUSIVE) {
-    errors.push({
-      file,
-      path: basePath,
-      message: `Condition nesting exceeds maximum depth of ${MAX_CONDITION_DEPTH_EXCLUSIVE}`,
-      severity: "error"
-    });
-    return;
-  }
-  for (let j = 0; j < conditions.length; j++) {
-    const cond = conditions[j];
-    if (!cond || typeof cond !== "object") continue;
-    const path = `${basePath}[${j}]`;
-    switch (cond.condition) {
-      case "time":
-        validateTimeCondition(cond, path, file, errors);
-        break;
-      case "state":
-        validateStateCondition(cond, path, event, file, errors, warnings);
-        break;
-      case "and":
-      case "or":
-      case "not":
-        if (Array.isArray(cond.conditions) && cond.conditions.length > 0) {
-          validateConditionsArray(cond.conditions, `${path}.conditions`, event, file, errors, warnings, depth + 1);
-        }
-        break;
-    }
-  }
-}
-function validateTimeCondition(cond, path, file, errors) {
-  if (cond.after !== void 0 && typeof cond.after === "string") {
-    if (!HH_MM_RE.test(cond.after)) {
-      errors.push({ file, path: `${path}.after`, message: `Invalid time format: "${cond.after}" (expected HH:MM)`, severity: "error" });
-    } else {
-      const [h, m] = cond.after.split(":").map(Number);
-      if ((h ?? 0) > 23 || (m ?? 0) > 59) {
-        errors.push({ file, path: `${path}.after`, message: `Invalid time value: "${cond.after}"`, severity: "error" });
-      }
-    }
-  }
-  if (cond.before !== void 0 && typeof cond.before === "string") {
-    if (!HH_MM_RE.test(cond.before)) {
-      errors.push({ file, path: `${path}.before`, message: `Invalid time format: "${cond.before}" (expected HH:MM)`, severity: "error" });
-    } else {
-      const [h, m] = cond.before.split(":").map(Number);
-      if ((h ?? 0) > 23 || (m ?? 0) > 59) {
-        errors.push({ file, path: `${path}.before`, message: `Invalid time value: "${cond.before}"`, severity: "error" });
-      }
-    }
-  }
-  if (cond.weekday !== void 0 && Array.isArray(cond.weekday)) {
-    for (const day of cond.weekday) {
-      if (typeof day === "string" && !VALID_WEEKDAYS2.has(day)) {
-        errors.push({ file, path: `${path}.weekday`, message: `Invalid weekday: "${day}" (expected mon-sun)`, severity: "error" });
-      }
-    }
-  }
-  if (cond.timezone !== void 0 && typeof cond.timezone === "string") {
-    try {
-      Intl.DateTimeFormat(void 0, { timeZone: cond.timezone });
-    } catch {
-      errors.push({ file, path: `${path}.timezone`, message: `Invalid timezone: "${cond.timezone}"`, severity: "error" });
-    }
-  }
-}
-function validateStateCondition(cond, path, event, file, errors, warnings) {
-  const hasValue = cond.value !== void 0;
-  const hasFrom = cond.from !== void 0;
-  const hasTo = cond.to !== void 0;
-  const hasContains = cond.contains !== void 0;
-  const hasNotValue = cond.not_value !== void 0;
-  const operatorCount = (hasValue ? 1 : 0) + (hasFrom || hasTo ? 1 : 0) + (hasContains ? 1 : 0) + (hasNotValue ? 1 : 0);
-  if (operatorCount === 0) {
-    errors.push({ file, path, message: "State condition must have at least one operator (value, from/to, contains, or not_value)", severity: "error" });
-  } else if (operatorCount > 1) {
-    errors.push({ file, path, message: "State condition must use exactly one operator group (value, from/to, contains, or not_value)", severity: "error" });
-  }
-  if ((hasFrom || hasTo) && !TRANSITION_EVENTS.has(event)) {
-    warnings.push({
-      file,
-      path,
-      message: `from/to transition checks are typically used with PermissionModeChange or SessionStatusChange events, not ${event}`,
-      severity: "warning"
-    });
-  }
-}
-function sanitizeForShell(value) {
-  return value.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$").replace(/"/g, '\\"').replace(/'/g, "\\'").replace(/\n/g, "\\n").replace(/\r/g, "\\r");
-}
-function createLogger(scope) {
-  return {
-    debug: (...args) => console.debug(`[${scope}]`, ...args),
-    info: (...args) => console.info(`[${scope}]`, ...args),
-    warn: (...args) => console.warn(`[${scope}]`, ...args),
-    error: (...args) => console.error(`[${scope}]`, ...args)
-  };
-}
-var log = createLogger("cron-matcher");
-function matchesCron(cronExpr, timezone) {
-  try {
-    const options = timezone ? { timezone } : {};
-    const job = new import_croner2.Cron(cronExpr, options);
-    const now = /* @__PURE__ */ new Date();
-    const startOfMinute = new Date(now);
-    startOfMinute.setSeconds(0, 0);
-    const checkFrom = new Date(startOfMinute.getTime() - 1e3);
-    const nextRun = job.nextRun(checkFrom);
-    log.debug(`[matchesCron] cron=${cronExpr}, tz=${timezone || "default"}`);
-    log.debug(`[matchesCron] now=${now.toISOString()}, startOfMinute=${startOfMinute.toISOString()}`);
-    log.debug(`[matchesCron] checkFrom=${checkFrom.toISOString()}, nextRun=${nextRun?.toISOString() || "null"}`);
-    if (!nextRun) {
-      log.debug(`[matchesCron] No nextRun, returning false`);
-      return false;
-    }
-    const matches = nextRun.getTime() >= startOfMinute.getTime() && nextRun.getTime() < startOfMinute.getTime() + 6e4;
-    log.debug(`[matchesCron] matches=${matches} (nextRun ${nextRun.getTime()} vs startOfMinute ${startOfMinute.getTime()} to ${startOfMinute.getTime() + 6e4})`);
-    return matches;
-  } catch (e) {
-    console.error(`[matchesCron] Error:`, e);
-    return false;
-  }
-}
-var TRANSITION_FIELDS = {
-  permissionMode: { to: "newMode", from: "oldMode" },
-  sessionStatus: { to: "newState", from: "oldState" }
-};
-var WEEKDAY_MAP = {
-  mon: 1,
-  tue: 2,
-  wed: 3,
-  thu: 4,
-  fri: 5,
-  sat: 6,
-  sun: 7
-};
-function evaluateConditions(conditions, context) {
-  if (conditions.length === 0) return true;
-  for (const condition of conditions) {
-    if (!evaluateCondition(condition, context, 0)) return false;
-  }
-  return true;
-}
-function evaluateCondition(condition, context, depth) {
-  if (depth >= MAX_CONDITION_DEPTH_EXCLUSIVE) return false;
-  switch (condition.condition) {
-    case "time":
-      return evaluateTimeCondition(condition, context);
-    case "state":
-      return evaluateStateCondition(condition, context);
-    case "and":
-    case "or":
-    case "not":
-      return evaluateLogicalCondition(condition, context, depth);
-    default:
-      return false;
-  }
-}
-function evaluateTimeCondition(condition, context) {
-  const now = context.now ?? /* @__PURE__ */ new Date();
-  const tz = condition.timezone ?? context.matcherTimezone;
-  const { hours, minutes, weekdayNum } = getTimeInTimezone(now, tz);
-  if (condition.weekday && condition.weekday.length > 0) {
-    const allowed = new Set(condition.weekday.map((d) => WEEKDAY_MAP[d]));
-    if (!allowed.has(weekdayNum)) return false;
-  }
-  const hasAfter = condition.after !== void 0;
-  const hasBefore = condition.before !== void 0;
-  if (!hasAfter && !hasBefore) return true;
-  const currentMinutes = hours * 60 + minutes;
-  const afterMinutes = hasAfter ? parseTimeToMinutes(condition.after) : 0;
-  const beforeMinutes = hasBefore ? parseTimeToMinutes(condition.before) : 0;
-  if (hasAfter && hasBefore) {
-    if (afterMinutes <= beforeMinutes) {
-      return currentMinutes >= afterMinutes && currentMinutes < beforeMinutes;
-    } else {
-      return currentMinutes >= afterMinutes || currentMinutes < beforeMinutes;
-    }
-  }
-  if (hasAfter) return currentMinutes >= afterMinutes;
-  return currentMinutes < beforeMinutes;
-}
-function parseTimeToMinutes(time) {
-  const [h, m] = time.split(":").map(Number);
-  return (h ?? 0) * 60 + (m ?? 0);
-}
-function getTimeInTimezone(date, timezone) {
-  if (timezone) {
-    try {
-      const formatter = new Intl.DateTimeFormat("en-US", {
-        timeZone: timezone,
-        hour: "numeric",
-        minute: "numeric",
-        weekday: "short",
-        hour12: false
-      });
-      const parts = formatter.formatToParts(date);
-      const hours2 = Number(parts.find((p) => p.type === "hour")?.value ?? 0);
-      const minutes2 = Number(parts.find((p) => p.type === "minute")?.value ?? 0);
-      const weekdayStr = parts.find((p) => p.type === "weekday")?.value?.toLowerCase().slice(0, 3) ?? "";
-      const weekdayNum2 = WEEKDAY_MAP[weekdayStr] ?? 0;
-      return { hours: hours2, minutes: minutes2, weekdayNum: weekdayNum2 };
-    } catch {
-    }
-  }
-  const hours = date.getHours();
-  const minutes = date.getMinutes();
-  const jsDay = date.getDay();
-  const weekdayNum = jsDay === 0 ? 7 : jsDay;
-  return { hours, minutes, weekdayNum };
-}
-function evaluateStateCondition(condition, context) {
-  const { field } = condition;
-  const { payload } = context;
-  const hasFrom = condition.from !== void 0;
-  const hasTo = condition.to !== void 0;
-  if (hasFrom || hasTo) {
-    const mapping = TRANSITION_FIELDS[field];
-    const toKey = mapping?.to ?? field;
-    const fromKey = mapping?.from ?? field;
-    if (hasTo && payload[toKey] !== condition.to) return false;
-    if (hasFrom && payload[fromKey] !== condition.from) return false;
-    return true;
-  }
-  if (condition.contains !== void 0) {
-    const arr = payload[field];
-    if (!Array.isArray(arr)) return false;
-    return arr.includes(condition.contains);
-  }
-  if (condition.not_value !== void 0) {
-    const fieldValue = payload[field];
-    if (fieldValue === void 0) return false;
-    return fieldValue !== condition.not_value;
-  }
-  if (condition.value !== void 0) {
-    return payload[field] === condition.value;
-  }
-  return false;
-}
-function evaluateLogicalCondition(condition, context, depth) {
-  const { conditions } = condition;
-  switch (condition.condition) {
-    case "and":
-      for (const sub of conditions) {
-        if (!evaluateCondition(sub, context, depth + 1)) return false;
-      }
-      return true;
-    case "or":
-      for (const sub of conditions) {
-        if (evaluateCondition(sub, context, depth + 1)) return true;
-      }
-      return false;
-    case "not":
-      for (const sub of conditions) {
-        if (evaluateCondition(sub, context, depth + 1)) return false;
-      }
-      return true;
-    default:
-      return false;
-  }
-}
-function toSnakeCase(str) {
-  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
-}
-function expandEnvVars(str, env) {
-  return str.replace(/\$\{([^}]+)\}/g, (_, varName) => env[varName] ?? "").replace(/\$([A-Z_][A-Z0-9_]*)/gi, (_, varName) => env[varName] ?? "");
-}
-function parsePromptReferences(prompt) {
-  const mentions = [];
-  const matches = prompt.matchAll(/(?:^|[\s(])@([a-zA-Z][a-zA-Z0-9-]*)/g);
-  for (const match of matches) {
-    const captured = match[1];
-    if (captured) {
-      const mention = captured.toLowerCase();
-      if (!mentions.includes(mention)) {
-        mentions.push(mention);
-      }
-    }
-  }
-  return { mentions };
-}
-function getMatchValue(event, data) {
-  switch (event) {
-    case "LabelAdd":
-    case "LabelRemove":
-      return String(data.label ?? "");
-    case "LabelConfigChange":
-      return "";
-    // Always matches
-    case "PermissionModeChange":
-      return String(data.newMode ?? "");
-    case "FlagChange":
-      return String(data.isFlagged ?? false);
-    case "SessionStatusChange":
-      return String(data.newStatus ?? data.newState ?? "");
-    case "PreToolUse":
-    case "PostToolUse":
-      return String(data.toolName ?? data.data?.tool_name ?? "");
-    case "SchedulerTick":
-      return "";
-    default:
-      return JSON.stringify(data);
-  }
-}
-function getMatchValueForSdkInput(event, input) {
-  switch (event) {
-    case "PreToolUse":
-    case "PostToolUse":
-    case "PostToolUseFailure":
-    case "PermissionRequest":
-      return input.tool_name ?? "";
-    case "Notification":
-      return input.message ?? "";
-    case "SessionStart":
-      return input.source ?? "";
-    case "SubagentStart":
-    case "SubagentStop":
-      return input.agent_type ?? "";
-    default:
-      return "";
-  }
-}
-function matchesBasePredicate(matcher, event, matchValue) {
-  if (matcher.enabled === false) return false;
-  if (event === "SchedulerTick") {
-    return !!matcher.cron && matchesCron(matcher.cron, matcher.timezone);
-  }
-  if (!matcher.matcher) return true;
-  try {
-    return new RegExp(matcher.matcher).test(matchValue);
-  } catch {
-    return false;
-  }
-}
-function matcherMatchesWithContext(matcher, event, context) {
-  if (!matchesBasePredicate(matcher, event, context.matchValue)) return false;
-  if (matcher.conditions?.length) {
-    return evaluateConditions(matcher.conditions, {
-      payload: context.payload,
-      matcherTimezone: context.matcherTimezone ?? matcher.timezone
-    });
-  }
-  return true;
-}
-function matcherMatches(matcher, event, data) {
-  return matcherMatchesWithContext(matcher, event, {
-    matchValue: getMatchValue(event, data),
-    payload: data,
-    matcherTimezone: matcher.timezone
-  });
-}
-function matcherMatchesSdk(matcher, event, input) {
-  return matcherMatchesWithContext(matcher, event, {
-    matchValue: getMatchValueForSdkInput(event, input),
-    payload: input,
-    matcherTimezone: matcher.timezone
-  });
-}
-function cleanEnv() {
-  return Object.fromEntries(
-    Object.entries(process.env).filter((e) => e[1] !== void 0)
-  );
-}
-var PAYLOAD_SKIP_KEYS = /* @__PURE__ */ new Set(["sessionId", "sessionName", "workspaceId", "timestamp"]);
-function buildBaseEventEnv(event, payload) {
-  const env = {
-    WEFT_EVENT: event,
-    WEFT_EVENT_DATA: JSON.stringify(payload)
-  };
-  if (payload.sessionId) env.WEFT_SESSION_ID = payload.sessionId;
-  if (payload.sessionName) env.WEFT_SESSION_NAME = payload.sessionName;
-  if (payload.workspaceId) env.WEFT_WORKSPACE_ID = payload.workspaceId;
-  const sessionMetadata = {};
-  if (payload.sessionId) sessionMetadata.id = payload.sessionId;
-  if (payload.sessionName) sessionMetadata.name = payload.sessionName;
-  if (Object.keys(sessionMetadata).length > 0) {
-    env.WEFT_SESSION_METADATA = JSON.stringify(sessionMetadata);
-  }
-  if (event === "SchedulerTick") {
-    const now = /* @__PURE__ */ new Date();
-    env.WEFT_LOCAL_TIME = now.toLocaleTimeString("en-US", { hour12: false, hour: "2-digit", minute: "2-digit" });
-    env.WEFT_LOCAL_DATE = now.toISOString().split("T")[0];
-  }
-  for (const [key, value] of Object.entries(payload)) {
-    if (PAYLOAD_SKIP_KEYS.has(key)) continue;
-    const envKey = `WEFT_${toSnakeCase(key).toUpperCase()}`;
-    env[envKey] = typeof value === "string" ? value : String(value);
-  }
-  return env;
-}
-function buildEnvFromPayload(event, payload) {
-  const base = buildBaseEventEnv(event, payload);
-  const env = { ...cleanEnv(), ...base };
-  if (payload.sessionName) env.WEFT_SESSION_NAME = sanitizeForShell(payload.sessionName);
-  for (const [key, value] of Object.entries(payload)) {
-    if (PAYLOAD_SKIP_KEYS.has(key)) continue;
-    const envKey = `WEFT_${toSnakeCase(key).toUpperCase()}`;
-    env[envKey] = typeof value === "string" ? sanitizeForShell(value) : String(value);
-  }
-  return env;
-}
-function buildWebhookEnv(event, payload) {
-  const env = buildBaseEventEnv(event, payload);
-  for (const [key, value] of Object.entries(process.env)) {
-    if (key.startsWith("WEFT_WH_") && value !== void 0) {
-      env[key] = value;
-    }
-  }
-  return env;
-}
-function buildEnvFromSdkInput(event, input) {
-  const env = {
-    ...cleanEnv(),
-    WEFT_EVENT: event
-  };
-  switch (event) {
-    case "PreToolUse":
-    case "PostToolUse":
-      if (input.tool_name) env.WEFT_TOOL_NAME = input.tool_name;
-      if (input.tool_input) env.WEFT_TOOL_INPUT = sanitizeForShell(JSON.stringify(input.tool_input));
-      if (input.tool_response) env.WEFT_TOOL_RESPONSE = sanitizeForShell(input.tool_response);
-      break;
-    case "PostToolUseFailure":
-      if (input.tool_name) env.WEFT_TOOL_NAME = input.tool_name;
-      if (input.tool_input) env.WEFT_TOOL_INPUT = sanitizeForShell(JSON.stringify(input.tool_input));
-      if (input.error) env.WEFT_ERROR = sanitizeForShell(input.error);
-      break;
-    case "UserPromptSubmit":
-      if (input.prompt) env.WEFT_PROMPT = sanitizeForShell(input.prompt);
-      break;
-    case "SessionStart":
-      if (input.source) env.WEFT_SOURCE = input.source;
-      if (input.model) env.WEFT_MODEL = input.model;
-      break;
-    case "SubagentStart":
-    case "SubagentStop":
-      if (input.agent_id) env.WEFT_AGENT_ID = input.agent_id;
-      if (input.agent_type) env.WEFT_AGENT_TYPE = input.agent_type;
-      break;
-    case "Notification":
-      if (input.message) env.WEFT_MESSAGE = sanitizeForShell(input.message);
-      if (input.title) env.WEFT_TITLE = sanitizeForShell(input.title);
-      break;
-    // SessionEnd, Stop, PreCompact, PermissionRequest, Setup have no additional fields
-    default:
-      break;
-  }
-  return env;
-}
-function createAutomationRuntimeGuard() {
-  const seen = /* @__PURE__ */ new Set();
-  return {
-    shouldDispatch(key) {
-      return !seen.has(keyString(key));
-    },
-    remember(key) {
-      seen.add(keyString(key));
-    }
-  };
-}
-async function executeAutomationPrompt(options) {
-  const automationId = automationIdForPrompt(options.prompt);
-  const origin = { type: "automation", id: automationId };
-  const dispatchKey = {
-    runtimeSessionId: options.runtime.sessionId,
-    automationId,
-    prompt: options.prompt.prompt
-  };
-  const triggered = createTriggeredItem(options.prompt, automationId, origin);
-  if (options.guard && !options.guard.shouldDispatch(dispatchKey)) {
-    return {
-      skipped: true,
-      timelineItems: [
-        triggered,
-        createResultItem(options.prompt, automationId, false, {
-          skipped: true,
-          reason: "automation loop guard blocked duplicate prompt dispatch"
-        })
-      ]
-    };
-  }
-  try {
-    await options.runtime.commands.sendMessage(options.prompt.prompt, {
-      commandOrigin: origin,
-      ...options.prompt.permissionMode ? { permissionMode: options.prompt.permissionMode } : {}
-    });
-    options.guard?.remember(dispatchKey);
-    return {
-      skipped: false,
-      timelineItems: [
-        triggered,
-        createResultItem(options.prompt, automationId, true)
-      ]
-    };
-  } catch (error) {
-    return {
-      skipped: false,
-      timelineItems: [
-        triggered,
-        createResultItem(options.prompt, automationId, false, {
-          reason: error instanceof Error ? error.message : String(error)
-        })
-      ]
-    };
-  }
-}
-function automationIdForPrompt(prompt) {
-  return prompt.matcherId ?? prompt.automationName ?? "automation";
-}
-function createTriggeredItem(prompt, automationId, origin) {
-  return {
-    type: "automation_triggered",
-    automation: {
-      automationId,
-      origin,
-      detail: {
-        name: prompt.automationName,
-        mentions: prompt.mentions,
-        labels: prompt.labels,
-        permissionMode: prompt.permissionMode
-      }
-    }
-  };
-}
-function createResultItem(prompt, automationId, success, extras = {}) {
-  return {
-    type: "automation_action_result",
-    result: {
-      type: "prompt",
-      automationId,
-      success,
-      sessionId: prompt.sessionId,
-      ...extras
-    }
-  };
-}
-function keyString(key) {
-  return `${key.runtimeSessionId}:${key.automationId}:${key.prompt}`;
-}
-function createAutomationTimelineBridge(options) {
-  return {
-    handleTimelineEnvelope(envelope) {
-      for (const event of projectTimelineEnvelopeToAutomationInput(envelope)) {
-        options.publish(event);
-      }
-    }
-  };
-}
-function projectTimelineEnvelopeToAutomationInput(envelope) {
-  const { item, sessionId, timestamp } = envelope;
-  switch (item.type) {
-    case "permission_requested":
-      return [{
-        event: "PermissionRequest",
-        source: "timeline",
-        sessionId,
-        matchValue: item.request.toolName,
-        payload: compactRecord({
-          requestId: item.request.requestId,
-          toolName: item.request.toolName,
-          reason: item.request.reason,
-          input: item.request.input,
-          scope: item.request.scope
-        }),
-        timestamp
-      }];
-    case "permission_resolved":
-      return [{
-        event: "PermissionResolved",
-        source: "policy",
-        sessionId,
-        matchValue: item.resolution.allowed ? "allowed" : "denied",
-        payload: {
-          requestId: item.requestId,
-          resolution: item.resolution
-        },
-        timestamp
-      }];
-    case "source_state_changed": {
-      const source = asRecord(item.source);
-      const sourceSlug = stringValue(source.sourceSlug) ?? stringValue(source.slug) ?? stringValue(source.id);
-      return [{
-        event: "SourceStateChange",
-        source: "source",
-        sessionId,
-        matchValue: sourceSlug,
-        payload: item.source,
-        timestamp
-      }];
-    }
-    case "skill_activated": {
-      const skill = asRecord(item.skill);
-      const skillSlug = stringValue(skill.skillSlug) ?? stringValue(skill.slug) ?? stringValue(skill.id);
-      return [{
-        event: "SkillActivated",
-        source: "skill",
-        sessionId,
-        matchValue: skillSlug,
-        payload: item.skill,
-        timestamp
-      }];
-    }
-    case "host_state_changed":
-      return hostStateEvents(item.state, sessionId, timestamp);
-    case "turn_started":
-      return [{
-        event: "SessionStart",
-        source: "timeline",
-        sessionId,
-        matchValue: item.turnId,
-        payload: item,
-        timestamp
-      }];
-    case "turn_completed":
-      return [{
-        event: "SessionEnd",
-        source: "timeline",
-        sessionId,
-        matchValue: item.turnId,
-        payload: item,
-        timestamp
-      }];
-    default:
-      return [];
-  }
-}
-function hostStateEvents(state, fallbackSessionId, timestamp) {
-  const record = asRecord(state);
-  const sessionId = stringValue(record.sessionId) ?? fallbackSessionId;
-  const events = [];
-  if (typeof record.status === "string") {
-    events.push({
-      event: "SessionStatusChange",
-      source: "host",
-      sessionId,
-      matchValue: record.status,
-      payload: state,
-      timestamp
-    });
-  }
-  if (typeof record.flagged === "boolean") {
-    events.push({
-      event: "FlagChange",
-      source: "host",
-      sessionId,
-      matchValue: String(record.flagged),
-      payload: state,
-      timestamp
-    });
-  }
-  if (Array.isArray(record.labels)) {
-    for (const label of record.labels) {
-      if (typeof label !== "string") continue;
-      events.push({
-        event: "LabelAdd",
-        source: "host",
-        sessionId,
-        matchValue: label,
-        payload: state,
-        timestamp
-      });
-    }
-  }
-  return events;
-}
-function compactRecord(record) {
-  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== void 0));
-}
-function asRecord(value) {
-  return value && typeof value === "object" ? value : {};
-}
-function stringValue(value) {
-  return typeof value === "string" ? value : void 0;
-}
-function createInMemoryAutomationHistoryStore(options = {}) {
-  const now = options.now ?? Date.now;
-  const maxEntries = options.maxEntries ?? Number.POSITIVE_INFINITY;
-  const records = [];
-  return {
-    async record(input) {
-      const record = {
-        ...cloneHistoryInput(input),
-        recordId: `automation-history:${records.length + 1}`,
-        attempt: input.attempt ?? 1,
-        timestamp: now()
-      };
-      records.push(record);
-      while (records.length > maxEntries) records.shift();
-      return cloneHistoryRecord(record);
-    },
-    async list(filter = {}) {
-      return filterHistoryRecords(records, filter).map(cloneHistoryRecord);
-    },
-    async getLastExecuted(matcherId) {
-      const record = [...records].reverse().find((candidate) => candidate.matcherId === matcherId && candidate.status !== "skipped");
-      return record ? cloneHistoryRecord(record) : void 0;
-    },
-    getSnapshot() {
-      return { records: records.map(cloneHistoryRecord) };
-    }
-  };
-}
-function automationHistoryInputForPromptResult(prompt, result) {
-  const actionResult = result.timelineItems.map((item) => item.type === "automation_action_result" ? item.result : void 0).find(Boolean);
-  const success = actionResult?.success === true;
-  const skipped = result.skipped || actionResult?.skipped === true;
-  const error = typeof actionResult?.reason === "string" ? actionResult.reason : void 0;
-  return {
-    matcherId: prompt.matcherId ?? prompt.automationName ?? "automation",
-    automationName: prompt.automationName,
-    sessionId: prompt.sessionId,
-    actionType: "prompt",
-    status: skipped ? "skipped" : success ? "success" : "failed",
-    skipped,
-    attempt: 1,
-    promptPreview: redactAutomationText(prompt.prompt),
-    ...error ? { error: redactAutomationText(error) } : {},
-    timelineItemCount: result.timelineItems.length
-  };
-}
-function filterHistoryRecords(records, filter) {
-  return records.filter((record) => !filter.matcherId || record.matcherId === filter.matcherId).filter((record) => !filter.sessionId || record.sessionId === filter.sessionId).filter((record) => !filter.status || record.status === filter.status).slice(0, filter.limit ?? Number.POSITIVE_INFINITY);
-}
-function cloneHistoryInput(input) {
-  return {
-    ...input,
-    ...input.metadata ? { metadata: { ...input.metadata } } : {}
-  };
-}
-function cloneHistoryRecord(record) {
-  return {
-    ...record,
-    ...record.metadata ? { metadata: { ...record.metadata } } : {}
-  };
-}
-function redactAutomationText(text) {
-  return text.replace(/(authorization\s*[:=]\s*)(bearer\s+)?[^\s,;]+/gi, (_match, prefix, bearer = "") => `${prefix}${bearer}[REDACTED]`).replace(/(token\s*[:=]\s*)[^\s,;]+/gi, (_match, prefix) => `${prefix}[REDACTED]`).replace(/(api[_-]?key\s*[:=]\s*)[^\s,;]+/gi, (_match, prefix) => `${prefix}[REDACTED]`).replace(/(secret\s*[:=]\s*)[^\s,;]+/gi, (_match, prefix) => `${prefix}[REDACTED]`);
-}
-function createAutomationSchedulerHost(options) {
-  const now = options.now ?? Date.now;
-  const schedules = /* @__PURE__ */ new Map();
-  return {
-    start(input) {
-      const registration = { ...input };
-      schedules.set(input.schedulerId, registration);
-      return {
-        ...registration,
-        state: "started",
-        timestamp: now()
-      };
-    },
-    stop(schedulerId) {
-      const registration = schedules.get(schedulerId);
-      if (!registration) return void 0;
-      schedules.delete(schedulerId);
-      return {
-        ...registration,
-        state: "stopped",
-        timestamp: now()
-      };
-    },
-    tick(schedulerId, tickOptions = {}) {
-      const registration = schedules.get(schedulerId);
-      if (!registration) return false;
-      void Promise.resolve(options.publish({
-        event: "SchedulerTick",
-        source: "host",
-        sessionId: registration.workspaceId,
-        matchValue: registration.schedulerId,
-        payload: {
-          ...registration,
-          ...tickOptions.reason ? { reason: tickOptions.reason } : {}
-        },
-        timestamp: now()
-      }));
-      return true;
-    },
-    getSnapshot() {
-      return {
-        schedules: [...schedules.values()].map((schedule) => ({ ...schedule }))
-      };
-    }
-  };
-}
-function createRuntimeAutomationBridge(options) {
-  const guard = options.guard ?? createAutomationRuntimeGuard();
-  const timelineBridge = createAutomationTimelineBridge({
-    publish(event) {
-      void Promise.resolve(options.publish(event)).catch((error) => {
-        options.onError?.(toError(error));
-      });
-    }
-  });
-  options.runtime.events.connect(
-    (envelope) => timelineBridge.handleTimelineEnvelope(envelope),
-    (error) => options.onError?.(error)
-  );
-  return {
-    async handlePromptsReady(prompts) {
-      const results = [];
-      for (const prompt of prompts) {
-        const result = await executeAutomationPrompt({
-          runtime: options.runtime,
-          prompt,
-          guard
-        });
-        results.push(result);
-        if (options.historyStore) {
-          await options.historyStore.record(automationHistoryInputForPromptResult(prompt, result));
-        }
-        if (!options.emitTimelineItem) continue;
-        for (const item of result.timelineItems) {
-          await options.emitTimelineItem(item);
-        }
-      }
-      return results;
-    },
-    dispose() {
-      options.runtime.events.disconnect();
-    }
-  };
-}
-function toError(error) {
-  return error instanceof Error ? error : new Error(String(error));
-}
-var AutomationEventLogger = class {
-  /** Callback when an event is lost due to buffer overflow */
-  onEventLost = null;
-  constructor(_workspaceRootPath) {
-  }
-  /**
-   * Log an automation event.
-   * Stub: no persistence in OSS package.
-   */
-  log(input) {
-  }
-  /**
-   * Get the path to the event log file.
-   * Stub: returns empty string.
-   */
-  getLogPath() {
-    return "";
-  }
-  /**
-   * Dispose the logger, flushing buffered events.
-   * Stub: no-op.
-   */
-  async dispose() {
-  }
-};
-function redactUrl(url) {
-  try {
-    const parsed = new URL(url);
-    if (parsed.pathname.length > 20) {
-      return `${parsed.origin}${parsed.pathname.slice(0, 15)}...`;
-    }
-    return `${parsed.origin}${parsed.pathname}`;
-  } catch {
-    return url.slice(0, 30) + "...";
-  }
-}
-function createWebhookHistoryEntry(opts) {
-  return {
-    id: opts.matcherId,
-    ts: Date.now(),
-    ok: opts.ok,
-    webhook: {
-      method: opts.method ?? DEFAULT_WEBHOOK_METHOD,
-      url: redactUrl(opts.url),
-      statusCode: opts.statusCode,
-      durationMs: opts.durationMs,
-      ...opts.attempts && opts.attempts > 1 ? { attempts: opts.attempts } : {},
-      ...opts.error ? { error: opts.error.slice(0, HISTORY_FIELD_MAX_LENGTH) } : {},
-      ...opts.responseBody ? { responseBody: opts.responseBody.slice(0, HISTORY_FIELD_MAX_LENGTH) } : {}
-    }
-  };
-}
-function createPromptHistoryEntry(opts) {
-  return {
-    id: opts.matcherId,
-    ts: Date.now(),
-    ok: opts.ok,
-    ...opts.sessionId ? { sessionId: opts.sessionId } : {},
-    ...opts.prompt ? { prompt: opts.prompt.slice(0, HISTORY_FIELD_MAX_LENGTH) } : {},
-    ...opts.error ? { error: opts.error.slice(0, HISTORY_FIELD_MAX_LENGTH) } : {}
-  };
-}
-function expandWebhookAction(action, env) {
-  const expanded = {
-    ...action,
-    url: expandEnvVars(action.url, env)
-  };
-  if (action.headers) {
-    expanded.headers = {};
-    for (const [key, value] of Object.entries(action.headers)) {
-      expanded.headers[key] = expandEnvVars(value, env);
-    }
-  }
-  if (typeof action.body === "string") {
-    expanded.body = expandEnvVars(action.body, env);
-  } else if (action.body !== void 0 && typeof action.body === "object" && action.body !== null) {
-    expanded.body = JSON.parse(expandEnvVars(JSON.stringify(action.body), env));
-  }
-  if (action.auth) {
-    if (action.auth.type === "basic") {
-      expanded.auth = {
-        type: "basic",
-        username: expandEnvVars(action.auth.username, env),
-        password: expandEnvVars(action.auth.password, env)
-      };
-    } else if (action.auth.type === "bearer") {
-      expanded.auth = {
-        type: "bearer",
-        token: expandEnvVars(action.auth.token, env)
-      };
-    }
-  }
-  return expanded;
-}
-var DEFAULT_TIMEOUT_MS = 3e4;
-async function executeWebhookRequest(action, options) {
-  const env = options?.env;
-  const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  const method = action.method ?? DEFAULT_WEBHOOK_METHOD;
-  const url = env ? expandEnvVars(action.url, env) : action.url;
-  try {
-    const parsed = new URL(url);
-    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-      return {
-        type: "webhook",
-        url,
-        statusCode: 0,
-        success: false,
-        error: `Invalid URL scheme "${parsed.protocol}" \u2014 only http and https are allowed`,
-        durationMs: 0
-      };
-    }
-  } catch {
-    return {
-      type: "webhook",
-      url,
-      statusCode: 0,
-      success: false,
-      error: `Invalid URL after variable expansion: "${url.slice(0, 50)}"`,
-      durationMs: 0
-    };
-  }
-  const start = Date.now();
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    const headers = {};
-    if (action.auth) {
-      if (action.auth.type === "basic") {
-        const user = env ? expandEnvVars(action.auth.username, env) : action.auth.username;
-        const pass = env ? expandEnvVars(action.auth.password, env) : action.auth.password;
-        headers["Authorization"] = `Basic ${btoa(`${user}:${pass}`)}`;
-      } else if (action.auth.type === "bearer") {
-        const token = env ? expandEnvVars(action.auth.token, env) : action.auth.token;
-        headers["Authorization"] = `Bearer ${token}`;
-      }
-    }
-    if (action.headers) {
-      for (const [key, value] of Object.entries(action.headers)) {
-        headers[key] = env ? expandEnvVars(value, env) : value;
-      }
-    }
-    let requestBody;
-    if (method !== "GET" && action.body !== void 0) {
-      const bodyFormat = action.bodyFormat ?? "json";
-      if (bodyFormat === "json") {
-        if (!headers["Content-Type"] && !headers["content-type"]) {
-          headers["Content-Type"] = "application/json";
-        }
-        if (typeof action.body === "string") {
-          requestBody = env ? expandEnvVars(action.body, env) : action.body;
-        } else {
-          const raw = JSON.stringify(action.body);
-          requestBody = env ? expandEnvVars(raw, env) : raw;
-        }
-      } else if (bodyFormat === "form") {
-        if (!headers["Content-Type"] && !headers["content-type"]) {
-          headers["Content-Type"] = "application/x-www-form-urlencoded";
-        }
-        if (typeof action.body === "object" && action.body !== null) {
-          const params = new URLSearchParams();
-          for (const [k, v] of Object.entries(action.body)) {
-            const val = String(v ?? "");
-            params.append(k, env ? expandEnvVars(val, env) : val);
-          }
-          requestBody = params.toString();
-        } else {
-          const raw = String(action.body);
-          requestBody = env ? expandEnvVars(raw, env) : raw;
-        }
-      } else {
-        const raw = String(action.body);
-        requestBody = env ? expandEnvVars(raw, env) : raw;
-      }
-    }
-    const response = await fetch(url, {
-      method,
-      headers,
-      body: requestBody,
-      signal: controller.signal
-    });
-    const success = response.status >= 200 && response.status < 300;
-    const MAX_RESPONSE_SIZE = 4096;
-    let responseBody;
-    try {
-      const text = await response.text();
-      if (action.captureResponse) {
-        responseBody = text.length > MAX_RESPONSE_SIZE ? text.slice(0, MAX_RESPONSE_SIZE) + "...(truncated)" : text;
-      }
-    } catch {
-    }
-    return {
-      type: "webhook",
-      url,
-      statusCode: response.status,
-      success,
-      error: success ? void 0 : `HTTP ${response.status} ${response.statusText}`,
-      durationMs: Date.now() - start,
-      ...responseBody !== void 0 ? { responseBody } : {}
-    };
-  } catch (err) {
-    const isTimeout = err instanceof DOMException && err.name === "AbortError";
-    const error = isTimeout ? `Request timed out after ${timeoutMs}ms` : err instanceof Error ? err.message : "Unknown error";
-    return {
-      type: "webhook",
-      url,
-      statusCode: 0,
-      success: false,
-      error,
-      durationMs: Date.now() - start
-    };
-  } finally {
-    clearTimeout(timeoutId);
-  }
-}
-function isTransientFailure(result) {
-  if (result.success) return false;
-  if (result.statusCode >= 400 && result.statusCode < 500) return false;
-  return true;
-}
-async function executeWithRetry(action, options) {
-  const maxAttempts = options?.retry?.maxAttempts ?? 0;
-  if (maxAttempts <= 0) {
-    const result = await executeWebhookRequest(action, options);
-    return { ...result, attempts: 1 };
-  }
-  const initialDelay = options?.retry?.initialDelayMs ?? 1e3;
-  const maxDelay = options?.retry?.maxDelayMs ?? 1e4;
-  const totalStart = Date.now();
-  let lastResult;
-  for (let attempt = 0; attempt <= maxAttempts; attempt++) {
-    lastResult = await executeWebhookRequest(action, options);
-    if (!isTransientFailure(lastResult)) {
-      return {
-        ...lastResult,
-        attempts: attempt + 1,
-        durationMs: Date.now() - totalStart
-      };
-    }
-    if (attempt === maxAttempts) break;
-    const delay = Math.min(initialDelay * Math.pow(2, attempt), maxDelay);
-    const jitter = delay * 0.1 * (Math.random() * 2 - 1);
-    await new Promise((r) => setTimeout(r, delay + jitter));
-  }
-  return {
-    ...lastResult,
-    attempts: maxAttempts + 1,
-    durationMs: Date.now() - totalStart
-  };
-}
-var log2 = createLogger("history-store");
-var mutexes = /* @__PURE__ */ new Map();
-function withMutex(key, fn) {
-  const prev = mutexes.get(key) ?? Promise.resolve();
-  const next = prev.then(fn, fn);
-  mutexes.set(key, next.then(() => {
-  }, () => {
-  }));
-  return next;
-}
-var appendCounters = /* @__PURE__ */ new Map();
-async function appendAutomationHistoryEntry(workspaceRootPath, entry) {
-  const historyPath = (0, import_path3.join)(workspaceRootPath, AUTOMATIONS_HISTORY_FILE);
-  await withMutex(workspaceRootPath, async () => {
-    await (0, import_promises2.appendFile)(historyPath, JSON.stringify(entry) + "\n", "utf-8");
-    const count = (appendCounters.get(workspaceRootPath) ?? 0) + 1;
-    appendCounters.set(workspaceRootPath, count);
-    if (count >= AUTOMATION_HISTORY_MAX_ENTRIES) {
-      appendCounters.set(workspaceRootPath, 0);
-      await runCompaction(historyPath);
-    }
-  });
-}
-async function compactAutomationHistory(workspaceRootPath, maxPerMatcher = AUTOMATION_HISTORY_MAX_RUNS_PER_MATCHER, maxTotal = AUTOMATION_HISTORY_MAX_ENTRIES) {
-  const historyPath = (0, import_path3.join)(workspaceRootPath, AUTOMATIONS_HISTORY_FILE);
-  await withMutex(workspaceRootPath, () => runCompaction(historyPath, maxPerMatcher, maxTotal));
-}
-function compactAutomationHistorySync(workspaceRootPath, maxPerMatcher = AUTOMATION_HISTORY_MAX_RUNS_PER_MATCHER, maxTotal = AUTOMATION_HISTORY_MAX_ENTRIES) {
-  const historyPath = (0, import_path3.join)(workspaceRootPath, AUTOMATIONS_HISTORY_FILE);
-  if (!(0, import_fs2.existsSync)(historyPath)) return;
-  let content;
-  try {
-    content = (0, import_fs2.readFileSync)(historyPath, "utf-8");
-  } catch {
-    return;
-  }
-  const result = compactEntries(content, maxPerMatcher, maxTotal);
-  if (!result) return;
-  (0, import_fs2.writeFileSync)(historyPath, result, "utf-8");
-  log2.debug(`[HistoryStore] Startup compaction complete`);
-}
-async function runCompaction(historyPath, maxPerMatcher = AUTOMATION_HISTORY_MAX_RUNS_PER_MATCHER, maxTotal = AUTOMATION_HISTORY_MAX_ENTRIES) {
-  let content;
-  try {
-    if (!(0, import_fs2.existsSync)(historyPath)) return;
-    content = await (0, import_promises2.readFile)(historyPath, "utf-8");
-  } catch {
-    return;
-  }
-  const result = compactEntries(content, maxPerMatcher, maxTotal);
-  if (!result) return;
-  await (0, import_promises2.writeFile)(historyPath, result, "utf-8");
-  log2.debug(`[HistoryStore] Compacted history`);
-}
-function compactEntries(content, maxPerMatcher, maxTotal) {
-  const lines = content.trim().split("\n").filter(Boolean);
-  if (lines.length === 0) return null;
-  const entries = [];
-  for (const line of lines) {
-    try {
-      const parsed = JSON.parse(line);
-      entries.push({ raw: line, id: parsed.id ?? "" });
-    } catch {
-    }
-  }
-  const originalLineCount = lines.length;
-  const byId = /* @__PURE__ */ new Map();
-  for (let i = 0; i < entries.length; i++) {
-    const id = entries[i].id;
-    let group = byId.get(id);
-    if (!group) {
-      group = [];
-      byId.set(id, group);
-    }
-    group.push(i);
-  }
-  const keepIndices = /* @__PURE__ */ new Set();
-  for (const indices of byId.values()) {
-    const kept = indices.slice(-maxPerMatcher);
-    for (const idx of kept) {
-      keepIndices.add(idx);
-    }
-  }
-  let trimmed = entries.filter((_, i) => keepIndices.has(i));
-  if (trimmed.length > maxTotal) {
-    trimmed = trimmed.slice(-maxTotal);
-  }
-  if (trimmed.length === originalLineCount) return null;
-  return trimmed.map((e) => e.raw).join("\n") + "\n";
-}
-var log3 = createLogger("retry-scheduler");
-var DEFERRED_DELAYS_MS = [
-  5 * 6e4,
-  // 5 minutes
-  30 * 6e4,
-  // 30 minutes
-  60 * 6e4
-  // 1 hour
-];
-var MAX_DEFERRED_ATTEMPTS = DEFERRED_DELAYS_MS.length;
-var TICK_INTERVAL_MS = 6e4;
-var RetryScheduler = class {
-  workspaceRootPath;
-  timer = null;
-  processing = false;
-  constructor(options) {
-    this.workspaceRootPath = options.workspaceRootPath;
-  }
-  /**
-   * Start the scheduler. Checks queue every minute.
-   */
-  start() {
-    if (this.timer) return;
-    this.timer = setInterval(() => this.tick(), TICK_INTERVAL_MS);
-    log3.debug("[RetryScheduler] Started");
-    setTimeout(() => this.tick(), 5e3);
-  }
-  /**
-   * Stop the scheduler and clean up.
-   */
-  dispose() {
-    if (this.timer) {
-      clearInterval(this.timer);
-      this.timer = null;
-    }
-    log3.debug("[RetryScheduler] Disposed");
-  }
-  /**
-   * Enqueue a failed webhook for deferred retry.
-   * Called by WebhookHandler when immediate retries are exhausted.
-   */
-  async enqueue(matcherId, action, expandedUrl, lastError) {
-    const entry = {
-      id: `${matcherId}-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
-      matcherId,
-      action,
-      expandedUrl,
-      deferredAttempt: 0,
-      nextRetryAt: Date.now() + DEFERRED_DELAYS_MS[0],
-      createdAt: Date.now(),
-      lastError
-    };
-    const queuePath = (0, import_path2.join)(this.workspaceRootPath, AUTOMATIONS_RETRY_QUEUE_FILE);
-    await (0, import_promises.appendFile)(queuePath, JSON.stringify(entry) + "\n", "utf-8");
-    log3.debug(`[RetryScheduler] Enqueued ${entry.id} \u2014 next retry in ${DEFERRED_DELAYS_MS[0] / 6e4}m`);
-  }
-  /**
-   * Process the queue: read entries, retry those that are due, rewrite the queue.
-   */
-  async tick() {
-    if (this.processing) return;
-    this.processing = true;
-    try {
-      const queuePath = (0, import_path2.join)(this.workspaceRootPath, AUTOMATIONS_RETRY_QUEUE_FILE);
-      let raw;
-      try {
-        raw = await (0, import_promises.readFile)(queuePath, "utf-8");
-      } catch {
-        return;
-      }
-      const lines = raw.trim().split("\n").filter(Boolean);
-      if (lines.length === 0) return;
-      const entries = [];
-      for (const line of lines) {
-        try {
-          entries.push(JSON.parse(line));
-        } catch {
-        }
-      }
-      if (entries.length === 0) return;
-      const now = Date.now();
-      const remaining = [];
-      for (const entry of entries) {
-        if (entry.nextRetryAt > now) {
-          remaining.push(entry);
-          continue;
-        }
-        log3.debug(`[RetryScheduler] Retrying ${entry.id} (deferred attempt ${entry.deferredAttempt + 1}/${MAX_DEFERRED_ATTEMPTS})`);
-        let result;
-        try {
-          result = await executeWebhookRequest(entry.action, { timeoutMs: 3e4 });
-        } catch (err) {
-          result = {
-            type: "webhook",
-            url: entry.expandedUrl,
-            statusCode: 0,
-            success: false,
-            error: err instanceof Error ? err.message : "Unknown error"
-          };
-        }
-        if (result.success) {
-          log3.debug(`[RetryScheduler] ${entry.id} succeeded on deferred attempt ${entry.deferredAttempt + 1}`);
-          const historyEntry = createWebhookHistoryEntry({
-            matcherId: entry.matcherId,
-            ok: true,
-            method: entry.action.method,
-            url: entry.expandedUrl,
-            statusCode: result.statusCode,
-            durationMs: result.durationMs ?? 0,
-            attempts: entry.deferredAttempt + 1
-          });
-          try {
-            await appendAutomationHistoryEntry(this.workspaceRootPath, historyEntry);
-          } catch (e) {
-            log3.debug(`[RetryScheduler] Failed to write history: ${e}`);
-          }
-        } else if (entry.deferredAttempt + 1 >= MAX_DEFERRED_ATTEMPTS) {
-          log3.debug(`[RetryScheduler] ${entry.id} permanently failed after ${MAX_DEFERRED_ATTEMPTS} deferred attempts`);
-          const historyEntry = createWebhookHistoryEntry({
-            matcherId: entry.matcherId,
-            ok: false,
-            method: entry.action.method,
-            url: entry.expandedUrl,
-            statusCode: result.statusCode,
-            durationMs: result.durationMs ?? 0,
-            attempts: entry.deferredAttempt + 1,
-            error: result.error ?? "Unknown error"
-          });
-          try {
-            await appendAutomationHistoryEntry(this.workspaceRootPath, historyEntry);
-          } catch (e) {
-            log3.debug(`[RetryScheduler] Failed to write history: ${e}`);
-          }
-        } else {
-          const nextDelay = DEFERRED_DELAYS_MS[entry.deferredAttempt + 1];
-          remaining.push({
-            ...entry,
-            deferredAttempt: entry.deferredAttempt + 1,
-            nextRetryAt: Date.now() + nextDelay,
-            lastError: result.error
-          });
-          log3.debug(`[RetryScheduler] ${entry.id} failed \u2014 next retry in ${nextDelay / 6e4}m`);
-        }
-      }
-      if (remaining.length === 0) {
-        await (0, import_promises.writeFile)(queuePath, "", "utf-8");
-      } else {
-        const content = remaining.map((e) => JSON.stringify(e)).join("\n") + "\n";
-        await (0, import_promises.writeFile)(queuePath, content, "utf-8");
-      }
-    } catch (err) {
-      log3.debug(`[RetryScheduler] Tick error: ${err}`);
-    } finally {
-      this.processing = false;
-    }
-  }
-};
-function loadAutomationsConfig(workspaceRootPath) {
-  const configPath = resolveAutomationsConfigPath(workspaceRootPath);
-  if (!(0, import_fs3.existsSync)(configPath)) {
-    return { config: null, configPath };
-  }
-  try {
-    const raw = JSON.parse((0, import_fs3.readFileSync)(configPath, "utf-8"));
-    return { config: raw, configPath };
-  } catch {
-    return { config: null, configPath };
-  }
-}
-function saveAutomationsConfig(workspaceRootPath, config) {
-  const validation = validateAutomationsConfig(config);
-  if (!validation.valid) {
-    return { ok: false, automationCount: 0, errors: validation.errors };
-  }
-  const configPath = resolveAutomationsConfigPath(workspaceRootPath);
-  (0, import_fs3.writeFileSync)(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
-  const automationCount = validation.config ? Object.values(validation.config.automations).reduce((sum, matchers) => sum + (matchers?.length ?? 0), 0) : 0;
-  return { ok: true, automationCount, errors: [] };
-}
-var log4 = createLogger("event-bus");
-var DEFAULT_RATE_LIMIT = 10;
-var SCHEDULER_RATE_LIMIT = 60;
-var RATE_WINDOW_MS = 6e4;
-function getRateLimit(event) {
-  return event === "SchedulerTick" ? SCHEDULER_RATE_LIMIT : DEFAULT_RATE_LIMIT;
-}
-var WorkspaceEventBus = class {
-  workspaceId;
-  handlers = /* @__PURE__ */ new Map();
-  anyHandlers = /* @__PURE__ */ new Set();
-  rateCounts = /* @__PURE__ */ new Map();
-  disposed = false;
-  constructor(workspaceId) {
-    this.workspaceId = workspaceId;
-    log4.debug(`[EventBus] Created for workspace: ${workspaceId}`);
-  }
-  /**
-   * Emit an event to all registered handlers.
-   * Handlers are called in parallel, errors are caught and logged.
-   */
-  async emit(event, payload) {
-    if (this.disposed) {
-      log4.warn(`[EventBus] Attempted to emit after disposal: ${event}`);
-      return;
-    }
-    const now = Date.now();
-    const rateWindow = this.rateCounts.get(event) ?? { count: 0, windowStart: now };
-    if (now - rateWindow.windowStart >= RATE_WINDOW_MS) {
-      rateWindow.count = 0;
-      rateWindow.windowStart = now;
-    }
-    const limit = getRateLimit(event);
-    if (rateWindow.count >= limit) {
-      log4.warn(
-        `[EventBus] Rate limit: ${event} fired ${rateWindow.count} times in ${Math.round((now - rateWindow.windowStart) / 1e3)}s (limit: ${limit}/min), dropping`
-      );
-      return;
-    }
-    rateWindow.count++;
-    this.rateCounts.set(event, rateWindow);
-    log4.debug(`[EventBus] Emitting: ${event}`);
-    const eventHandlers = this.handlers.get(event) ?? /* @__PURE__ */ new Set();
-    const anyHandlersCopy = new Set(this.anyHandlers);
-    const eventPromises = Array.from(eventHandlers).map(async (handler) => {
-      try {
-        await handler(payload);
-      } catch (error) {
-        log4.error(`[EventBus] Handler error for ${event}:`, error);
-      }
-    });
-    const anyPromises = Array.from(anyHandlersCopy).map(async (handler) => {
-      try {
-        await handler(event, payload);
-      } catch (error) {
-        log4.error(`[EventBus] Any-handler error for ${event}:`, error);
-      }
-    });
-    await Promise.all([...eventPromises, ...anyPromises]);
-    log4.debug(`[EventBus] Emitted: ${event} (${eventHandlers.size} handlers, ${anyHandlersCopy.size} any-handlers)`);
-  }
-  /**
-   * Register a handler for a specific event type.
-   */
-  on(event, handler) {
-    if (this.disposed) {
-      log4.warn(`[EventBus] Attempted to register handler after disposal: ${event}`);
-      return;
-    }
-    if (!this.handlers.has(event)) {
-      this.handlers.set(event, /* @__PURE__ */ new Set());
-    }
-    this.handlers.get(event).add(handler);
-    log4.debug(`[EventBus] Registered handler for: ${event}`);
-  }
-  /**
-   * Unregister a handler for a specific event type.
-   */
-  off(event, handler) {
-    const eventHandlers = this.handlers.get(event);
-    if (eventHandlers) {
-      eventHandlers.delete(handler);
-      log4.debug(`[EventBus] Unregistered handler for: ${event}`);
-    }
-  }
-  /**
-   * Register a handler for all events.
-   * Useful for logging, metrics, or debugging.
-   */
-  onAny(handler) {
-    if (this.disposed) {
-      log4.warn(`[EventBus] Attempted to register any-handler after disposal`);
-      return;
-    }
-    this.anyHandlers.add(handler);
-    log4.debug(`[EventBus] Registered any-handler`);
-  }
-  /**
-   * Unregister an all-events handler.
-   */
-  offAny(handler) {
-    this.anyHandlers.delete(handler);
-    log4.debug(`[EventBus] Unregistered any-handler`);
-  }
-  /**
-   * Clean up all handlers and mark as disposed.
-   */
-  dispose() {
-    if (this.disposed) return;
-    log4.debug(`[EventBus] Disposing for workspace: ${this.workspaceId}`);
-    this.handlers.clear();
-    this.anyHandlers.clear();
-    this.rateCounts.clear();
-    this.disposed = true;
-  }
-  /**
-   * Check if the bus has been disposed.
-   */
-  isDisposed() {
-    return this.disposed;
-  }
-  /**
-   * Get the workspace ID this bus belongs to.
-   */
-  getWorkspaceId() {
-    return this.workspaceId;
-  }
-  /**
-   * Get handler count for debugging.
-   */
-  getHandlerCount(event) {
-    if (event) {
-      return this.handlers.get(event)?.size ?? 0;
-    }
-    let total = this.anyHandlers.size;
-    for (const handlers of this.handlers.values()) {
-      total += handlers.size;
-    }
-    return total;
-  }
-};
-function deriveAutomationName(event, matcher) {
-  if (matcher.name) return matcher.name;
-  const firstAction = matcher.actions[0];
-  if (!firstAction) return event;
-  if (firstAction.type === "webhook") {
-    const label = `Webhook ${firstAction.method ?? "POST"} ${firstAction.url}`;
-    return label.length > 40 ? label.slice(0, 40) + "..." : label;
-  }
-  const mentionMatch = firstAction.prompt.match(/@(\S+)/);
-  if (mentionMatch) return `${mentionMatch[1]} prompt`;
-  return firstAction.prompt.length > 40 ? firstAction.prompt.slice(0, 40) + "..." : firstAction.prompt;
-}
-var log5 = createLogger("prompt-handler");
-var PromptHandler = class {
-  options;
-  configProvider;
-  bus = null;
-  boundHandler = null;
-  constructor(options, configProvider) {
-    this.options = options;
-    this.configProvider = configProvider;
-  }
-  /**
-   * Subscribe to App events on the bus.
-   */
-  subscribe(bus) {
-    this.bus = bus;
-    this.boundHandler = this.handleEvent.bind(this);
-    bus.onAny(this.boundHandler);
-    log5.debug(`[PromptHandler] Subscribed to event bus`);
-  }
-  /**
-   * Handle an event by processing matching prompt actions.
-   */
-  async handleEvent(event, payload) {
-    if (!APP_EVENTS.includes(event)) {
-      return;
-    }
-    const matchers = this.configProvider.getMatchersForEvent(event);
-    if (matchers.length === 0) return;
-    const matcherPrompts = [];
-    for (const matcher of matchers) {
-      if (!matcherMatches(matcher, event, payload)) continue;
-      const prompts = [];
-      for (const action of matcher.actions) {
-        if (action.type === "prompt") {
-          prompts.push({ prompt: action, labels: matcher.labels, permissionMode: matcher.permissionMode });
-        }
-      }
-      if (prompts.length > 0) {
-        const telegramTopic = matcher.telegramTopic?.trim();
-        matcherPrompts.push({
-          matcherId: matcher.id,
-          automationName: deriveAutomationName(event, matcher),
-          telegramTopic: telegramTopic && telegramTopic.length > 0 ? telegramTopic : void 0,
-          prompts
-        });
-      }
-    }
-    if (matcherPrompts.length === 0) return;
-    const totalPrompts = matcherPrompts.reduce((s, m) => s + m.prompts.length, 0);
-    log5.debug(`[PromptHandler] Processing ${totalPrompts} prompts for ${event}`);
-    const env = buildEnvFromPayload(event, payload);
-    const pendingPrompts = [];
-    for (const { matcherId, automationName, telegramTopic, prompts } of matcherPrompts) {
-      const expandedTopic = telegramTopic ? expandEnvVars(telegramTopic, env).trim() : void 0;
-      const finalTopic = expandedTopic && expandedTopic.length > 0 ? expandedTopic : void 0;
-      for (const { prompt, labels, permissionMode } of prompts) {
-        const expandedPrompt = expandEnvVars(prompt.prompt, env);
-        const references = parsePromptReferences(expandedPrompt);
-        const expandedLabels = labels?.map((label) => expandEnvVars(label, env));
-        pendingPrompts.push({
-          sessionId: this.options.sessionId,
-          matcherId,
-          automationName,
-          prompt: expandedPrompt,
-          mentions: references.mentions,
-          labels: expandedLabels,
-          permissionMode,
-          llmConnection: prompt.llmConnection,
-          model: prompt.model,
-          thinkingLevel: prompt.thinkingLevel,
-          telegramTopic: finalTopic
-        });
-      }
-    }
-    if (pendingPrompts.length > 0 && this.options.onPromptsReady) {
-      log5.debug(`[PromptHandler] Delivering ${pendingPrompts.length} prompts`);
-      this.options.onPromptsReady(pendingPrompts);
-    }
-  }
-  /**
-   * Clean up resources.
-   */
-  dispose() {
-    if (this.bus && this.boundHandler) {
-      this.bus.offAny(this.boundHandler);
-      this.boundHandler = null;
-    }
-    this.bus = null;
-    log5.debug(`[PromptHandler] Disposed`);
-  }
-};
-var log6 = createLogger("event-log-handler");
-var EventLogHandler = class {
-  options;
-  logger;
-  bus = null;
-  boundHandler = null;
-  constructor(options) {
-    this.options = options;
-    this.logger = new AutomationEventLogger(options.workspaceRootPath);
-    if (options.onEventLost) {
-      this.logger.onEventLost = (_loggedEvent) => {
-      };
-    }
-  }
-  /**
-   * Subscribe to all events on the bus.
-   */
-  subscribe(bus) {
-    this.bus = bus;
-    this.boundHandler = this.handleEvent.bind(this);
-    bus.onAny(this.boundHandler);
-    log6.debug(`[EventLogHandler] Subscribed to event bus, logging to ${this.logger.getLogPath()}`);
-  }
-  /**
-   * Handle an event by logging it.
-   */
-  async handleEvent(event, payload) {
-    const startTime = payload.timestamp;
-    const durationMs = Date.now() - startTime;
-    this.logger.log({
-      event,
-      sessionId: payload.sessionId,
-      workspaceId: this.options.workspaceId,
-      data: { ...payload }
-    });
-    log6.debug(`[EventLogHandler] Logged: ${event}`);
-  }
-  /**
-   * Get the path to the event log file.
-   */
-  getLogPath() {
-    return this.logger.getLogPath();
-  }
-  /**
-   * Clean up resources.
-   */
-  async dispose() {
-    if (this.bus && this.boundHandler) {
-      this.bus.offAny(this.boundHandler);
-      this.boundHandler = null;
-    }
-    this.bus = null;
-    await this.logger.dispose();
-    log6.debug(`[EventLogHandler] Disposed`);
-  }
-};
-var log7 = createLogger("webhook-handler");
-var EndpointRateLimiter = class {
-  windows = /* @__PURE__ */ new Map();
-  maxPerMinute;
-  cleanupTimer = null;
-  constructor(maxPerMinute = 30) {
-    this.maxPerMinute = maxPerMinute;
-    this.cleanupTimer = setInterval(() => {
-      const cutoff = Date.now() - 12e4;
-      for (const [origin, timestamps] of this.windows) {
-        if (timestamps.every((t) => t < cutoff)) {
-          this.windows.delete(origin);
-        }
-      }
-    }, 3e5);
-  }
-  /** Returns true if the request is allowed */
-  allow(url) {
-    const origin = this.getOrigin(url);
-    const now = Date.now();
-    const windowStart = now - 6e4;
-    let timestamps = this.windows.get(origin);
-    if (timestamps) {
-      timestamps = timestamps.filter((t) => t > windowStart);
-    } else {
-      timestamps = [];
-    }
-    if (timestamps.length >= this.maxPerMinute) {
-      return false;
-    }
-    timestamps.push(now);
-    this.windows.set(origin, timestamps);
-    return true;
-  }
-  getOrigin(url) {
-    try {
-      return new URL(url).origin;
-    } catch {
-      return url;
-    }
-  }
-  dispose() {
-    if (this.cleanupTimer) {
-      clearInterval(this.cleanupTimer);
-      this.cleanupTimer = null;
-    }
-    this.windows.clear();
-  }
-};
-var WebhookHandler = class {
-  options;
-  configProvider;
-  rateLimiter = new EndpointRateLimiter(30);
-  retryScheduler;
-  bus = null;
-  boundHandler = null;
-  constructor(options, configProvider) {
-    this.options = options;
-    this.configProvider = configProvider;
-    this.retryScheduler = new RetryScheduler({ workspaceRootPath: options.workspaceRootPath });
-  }
-  /**
-   * Subscribe to App events on the bus.
-   */
-  subscribe(bus) {
-    this.bus = bus;
-    this.boundHandler = this.handleEvent.bind(this);
-    bus.onAny(this.boundHandler);
-    this.retryScheduler.start();
-    log7.debug(`[WebhookHandler] Subscribed to event bus`);
-  }
-  /**
-   * Handle an event by processing matching webhook actions.
-   */
-  async handleEvent(event, payload) {
-    if (!APP_EVENTS.includes(event)) {
-      return;
-    }
-    const matchers = this.configProvider.getMatchersForEvent(event);
-    if (matchers.length === 0) return;
-    const webhookTasks = [];
-    for (const matcher of matchers) {
-      if (!matcherMatches(matcher, event, payload)) continue;
-      for (const action of matcher.actions) {
-        if (action.type === "webhook") {
-          webhookTasks.push({ action, matcherId: matcher.id ?? "unknown" });
-        }
-      }
-    }
-    if (webhookTasks.length === 0) return;
-    log7.debug(`[WebhookHandler] Processing ${webhookTasks.length} webhooks for ${event}`);
-    const env = buildWebhookEnv(event, payload);
-    const results = new Array(webhookTasks.length);
-    const toExecute = [];
-    for (let i = 0; i < webhookTasks.length; i++) {
-      const task = webhookTasks[i];
-      const resolvedUrl = expandEnvVars(task.action.url, env);
-      if (!this.rateLimiter.allow(resolvedUrl)) {
-        log7.debug(`[WebhookHandler] Rate-limited: ${redactUrl(resolvedUrl)}`);
-        results[i] = {
-          type: "webhook",
-          url: resolvedUrl,
-          statusCode: 0,
-          success: false,
-          error: "Rate-limited: too many requests to this endpoint",
-          durationMs: 0,
-          attempts: 0
-        };
-      } else {
-        toExecute.push({ index: i, task });
-      }
-    }
-    if (toExecute.length > 0) {
-      const webhookOpts = { env, retry: { maxAttempts: 2 } };
-      const outcomes = await Promise.allSettled(
-        toExecute.map(({ task }) => executeWithRetry(task.action, webhookOpts))
-      );
-      for (let j = 0; j < outcomes.length; j++) {
-        const outcome = outcomes[j];
-        const { index, task } = toExecute[j];
-        if (outcome.status === "fulfilled") {
-          results[index] = outcome.value;
-        } else {
-          results[index] = {
-            type: "webhook",
-            url: task.action.url,
-            statusCode: 0,
-            success: false,
-            error: outcome.reason?.message ?? "Unknown error"
-          };
-        }
-      }
-    }
-    for (let i = 0; i < results.length; i++) {
-      const result = results[i];
-      const task = webhookTasks[i];
-      if (!result.success) {
-        log7.debug(`[WebhookHandler] ${result.url} \u2192 ${result.error}`);
-      }
-      const entry = createWebhookHistoryEntry({
-        matcherId: task.matcherId,
-        ok: result.success,
-        method: task.action.method,
-        url: result.url,
-        statusCode: result.statusCode,
-        durationMs: result.durationMs ?? 0,
-        attempts: result.attempts,
-        error: result.error,
-        responseBody: result.responseBody
-      });
-      try {
-        await appendAutomationHistoryEntry(this.options.workspaceRootPath, entry);
-      } catch (e) {
-        log7.debug(`[WebhookHandler] Failed to write history: ${e}`);
-      }
-      if (isTransientFailure(result)) {
-        if (result.attempts && result.attempts > 1) {
-          const expandedAction = expandWebhookAction(task.action, env);
-          this.retryScheduler.enqueue(task.matcherId, expandedAction, result.url, result.error).catch((e) => log7.debug(`[WebhookHandler] Failed to enqueue for deferred retry: ${e}`));
-        }
-      }
-    }
-    if (results.length > 0 && this.options.onWebhookResults) {
-      log7.debug(`[WebhookHandler] Delivering ${results.length} webhook results`);
-      this.options.onWebhookResults(results);
-    }
-  }
-  /**
-   * Clean up resources.
-   */
-  dispose() {
-    if (this.bus && this.boundHandler) {
-      this.bus.offAny(this.boundHandler);
-      this.boundHandler = null;
-    }
-    this.bus = null;
-    this.rateLimiter.dispose();
-    this.retryScheduler.dispose();
-    log7.debug(`[WebhookHandler] Disposed`);
-  }
-};
-var SchedulerService = class {
-  callback;
-  constructor(callback) {
-    this.callback = callback;
-  }
-  start() {
-  }
-  stop() {
-  }
-};
-var log8 = createLogger("automation-system");
-var AutomationSystem = class {
-  eventBus;
-  options;
-  config = null;
-  promptHandler = null;
-  webhookHandler = null;
-  eventLogHandler = null;
-  scheduler = null;
-  disposed = false;
-  // Session metadata tracking (moved from SessionManager)
-  lastKnownMetadata = /* @__PURE__ */ new Map();
-  constructor(options) {
-    this.options = options;
-    this.eventBus = new WorkspaceEventBus(options.workspaceId);
-    this.loadConfig();
-    this.createHandlers();
-    if (options.enableScheduler) {
-      this.startScheduler();
-    }
-    log8.debug(`[AutomationSystem] Created for workspace: ${options.workspaceId}`);
-  }
-  // ============================================================================
-  // Configuration
-  // ============================================================================
-  /**
-   * Read, parse, and validate automations.json. Shared pipeline for loadConfig/reloadConfig.
-   * Returns the raw parsed JSON alongside validation results (avoids re-reading for backfillIds).
-   */
-  readAndValidateConfig(configPath) {
-    const raw = JSON.parse((0, import_fs4.readFileSync)(configPath, "utf-8"));
-    const validation = validateAutomationsConfig(raw);
-    return { raw, validation };
-  }
-  /**
-   * Load automations configuration from automations.json.
-   */
-  loadConfig() {
-    const configPath = resolveAutomationsConfigPath(this.options.workspaceRootPath);
-    if (!(0, import_fs4.existsSync)(configPath)) {
-      log8.debug(`[AutomationSystem] No automations config found at ${configPath}`);
-      this.config = { automations: {} };
-      return;
-    }
-    try {
-      const { raw, validation } = this.readAndValidateConfig(configPath);
-      if (!validation.valid) {
-        console.warn("[AutomationSystem] Invalid automations config:", validation.errors);
-        this.config = { automations: {} };
-        return;
-      }
-      this.config = validation.config;
-      this.backfillIds(configPath, raw);
-      this.rotateHistory();
-      const actionCount = this.getActionCount();
-      log8.debug(`[AutomationSystem] Loaded ${actionCount} actions from ${configPath}`);
-    } catch (e) {
-      const error = e instanceof Error ? e.message : "Unknown error";
-      console.warn("[AutomationSystem] Failed to load automations config:", error);
-      this.config = { automations: {} };
-    }
-  }
-  /**
-   * Reload automations configuration.
-   * Call this when automations.json changes.
-   */
-  reloadConfig() {
-    const configPath = resolveAutomationsConfigPath(this.options.workspaceRootPath);
-    if (!(0, import_fs4.existsSync)(configPath)) {
-      this.config = { automations: {} };
-      return { success: true, automationCount: 0, errors: [] };
-    }
-    try {
-      const { raw, validation } = this.readAndValidateConfig(configPath);
-      if (!validation.valid) {
-        return { success: false, automationCount: 0, errors: validation.errors };
-      }
-      this.config = validation.config;
-      this.backfillIds(configPath, raw);
-      const actionCount = this.getActionCount();
-      log8.debug(`[AutomationSystem] Reloaded ${actionCount} actions`);
-      return { success: true, automationCount: actionCount, errors: [] };
-    } catch (e) {
-      const error = e instanceof Error ? e.message : "Unknown error";
-      return { success: false, automationCount: 0, errors: [`Failed to parse JSON: ${error}`] };
-    }
-  }
-  /**
-   * Backfill missing IDs on matchers in the raw config.
-   * Operates on the already-parsed raw JSON to avoid re-reading from disk.
-   * Only writes if IDs were actually missing — no-op on subsequent loads.
-   */
-  backfillIds(configPath, raw) {
-    try {
-      const obj = raw;
-      const eventMap = obj.automations ?? obj.tasks ?? obj.hooks;
-      if (!eventMap) return;
-      let changed = false;
-      for (const matchers of Object.values(eventMap)) {
-        if (!Array.isArray(matchers)) continue;
-        for (const m of matchers) {
-          if (!m.id) {
-            m.id = generateShortId();
-            changed = true;
-          }
-        }
-      }
-      if (changed) {
-        (0, import_fs4.writeFileSync)(configPath, JSON.stringify(raw, null, 2) + "\n", "utf-8");
-        log8.debug("[AutomationSystem] Backfilled missing matcher IDs");
-      }
-    } catch {
-    }
-  }
-  /**
-   * Compact automations-history.jsonl on startup: two-tier retention.
-   * 1) Keep only the last N entries per automation ID.
-   * 2) If total still exceeds the global cap, drop oldest globally.
-   * Runs synchronously during init — single-threaded, no race with concurrent appends.
-   */
-  rotateHistory() {
-    try {
-      compactAutomationHistorySync(this.options.workspaceRootPath);
-    } catch {
-    }
-  }
-  /**
-   * Get total number of actions.
-   */
-  getActionCount() {
-    if (!this.config) return 0;
-    return Object.values(this.config.automations).reduce(
-      (sum, matchers) => sum + (matchers?.reduce((s, m) => s + m.actions.length, 0) ?? 0),
-      0
-    );
-  }
-  // ============================================================================
-  // AutomationsConfigProvider Implementation
-  // ============================================================================
-  getConfig() {
-    return this.config;
-  }
-  getMatchersForEvent(event) {
-    return this.config?.automations[event] ?? [];
-  }
-  // ============================================================================
-  // Handlers
-  // ============================================================================
-  /**
-   * Create and register all handlers.
-   */
-  createHandlers() {
-    this.promptHandler = new PromptHandler(
-      {
-        workspaceId: this.options.workspaceId,
-        workspaceRootPath: this.options.workspaceRootPath,
-        onPromptsReady: this.options.onPromptsReady,
-        onError: this.options.onError
-      },
-      this
-    );
-    this.promptHandler.subscribe(this.eventBus);
-    this.webhookHandler = new WebhookHandler(
-      {
-        workspaceId: this.options.workspaceId,
-        workspaceRootPath: this.options.workspaceRootPath,
-        onWebhookResults: this.options.onWebhookResults,
-        onError: this.options.onError
-      },
-      this
-    );
-    this.webhookHandler.subscribe(this.eventBus);
-    this.eventLogHandler = new EventLogHandler({
-      workspaceRootPath: this.options.workspaceRootPath,
-      workspaceId: this.options.workspaceId,
-      onEventLost: this.options.onEventLost
-    });
-    this.eventLogHandler.subscribe(this.eventBus);
-    log8.debug(`[AutomationSystem] Handlers created and subscribed`);
-  }
-  // ============================================================================
-  // Scheduler
-  // ============================================================================
-  /**
-   * Start the scheduler service.
-   */
-  startScheduler() {
-    if (this.scheduler) return;
-    this.scheduler = new SchedulerService(async (payload) => {
-      await this.eventBus.emit("SchedulerTick", {
-        workspaceId: this.options.workspaceId,
-        timestamp: Date.now(),
-        localTime: payload.localTime,
-        utcTime: payload.utcTime
-      });
-    });
-    this.scheduler.start();
-    log8.debug(`[AutomationSystem] Scheduler started`);
-  }
-  /**
-   * Stop the scheduler service.
-   */
-  stopScheduler() {
-    if (this.scheduler) {
-      this.scheduler.stop();
-      this.scheduler = null;
-      log8.debug(`[AutomationSystem] Scheduler stopped`);
-    }
-  }
-  // ============================================================================
-  // Session Metadata Diffing
-  // ============================================================================
-  /**
-   * Update session metadata and emit events for changes.
-   *
-   * This replaces the diffing logic that was in SessionManager.
-   * Call this whenever session metadata changes.
-   *
-   * @param sessionId - The session ID
-   * @param next - The new metadata snapshot
-   * @returns The events that were emitted
-   */
-  async updateSessionMetadata(sessionId, next) {
-    const prev = this.lastKnownMetadata.get(sessionId) ?? {};
-    const emittedEvents = [];
-    const timestamp = Date.now();
-    const sessionName = next.sessionName;
-    const labels = next.labels ?? [];
-    if (prev.permissionMode !== next.permissionMode) {
-      await this.eventBus.emit("PermissionModeChange", {
-        sessionId,
-        sessionName,
-        workspaceId: this.options.workspaceId,
-        timestamp,
-        labels,
-        oldMode: prev.permissionMode ?? "",
-        newMode: next.permissionMode ?? ""
-      });
-      emittedEvents.push("PermissionModeChange");
-    }
-    const prevLabels = new Set(prev.labels ?? []);
-    const nextLabels = new Set(next.labels ?? []);
-    for (const label of nextLabels) {
-      if (!prevLabels.has(label)) {
-        await this.eventBus.emit("LabelAdd", {
-          sessionId,
-          sessionName,
-          workspaceId: this.options.workspaceId,
-          timestamp,
-          labels: [...nextLabels],
-          label
-        });
-        emittedEvents.push("LabelAdd");
-      }
-    }
-    for (const label of prevLabels) {
-      if (!nextLabels.has(label)) {
-        await this.eventBus.emit("LabelRemove", {
-          sessionId,
-          sessionName,
-          workspaceId: this.options.workspaceId,
-          timestamp,
-          labels: [...nextLabels],
-          label
-        });
-        emittedEvents.push("LabelRemove");
-      }
-    }
-    const wasFlagged = prev.isFlagged ?? false;
-    const isFlagged = next.isFlagged ?? false;
-    if (wasFlagged !== isFlagged) {
-      await this.eventBus.emit("FlagChange", {
-        sessionId,
-        sessionName,
-        workspaceId: this.options.workspaceId,
-        timestamp,
-        labels,
-        isFlagged
-      });
-      emittedEvents.push("FlagChange");
-    }
-    if (prev.sessionStatus !== next.sessionStatus) {
-      await this.eventBus.emit("SessionStatusChange", {
-        sessionId,
-        sessionName,
-        workspaceId: this.options.workspaceId,
-        timestamp,
-        labels,
-        oldState: prev.sessionStatus ?? "",
-        newState: next.sessionStatus ?? ""
-      });
-      emittedEvents.push("SessionStatusChange");
-    }
-    this.lastKnownMetadata.set(sessionId, { ...next });
-    if (emittedEvents.length > 0) {
-      log8.debug(`[AutomationSystem] Emitted ${emittedEvents.length} events for session ${sessionId}: ${emittedEvents.join(", ")}`);
-    }
-    return emittedEvents;
-  }
-  /**
-   * Remove session metadata tracking.
-   * Call this when a session is deleted.
-   */
-  removeSessionMetadata(sessionId) {
-    this.lastKnownMetadata.delete(sessionId);
-    log8.debug(`[AutomationSystem] Removed metadata for session ${sessionId}`);
-  }
-  /**
-   * Get stored metadata for a session.
-   */
-  getSessionMetadata(sessionId) {
-    return this.lastKnownMetadata.get(sessionId);
-  }
-  /**
-   * Set initial metadata for a session (without emitting events).
-   * Call this when loading existing sessions.
-   */
-  setInitialSessionMetadata(sessionId, metadata) {
-    this.lastKnownMetadata.set(sessionId, { ...metadata });
-  }
-  // ============================================================================
-  // Direct Event Emission
-  // ============================================================================
-  /**
-   * Emit a LabelConfigChange event.
-   * Call this when labels/config.json changes.
-   */
-  async emitLabelConfigChange() {
-    await this.eventBus.emit("LabelConfigChange", {
-      workspaceId: this.options.workspaceId,
-      timestamp: Date.now()
-    });
-  }
-  /**
-   * Emit an event directly (for edge cases).
-   */
-  async emit(event, payload) {
-    await this.eventBus.emit(event, payload);
-  }
-  // ============================================================================
-  // Agent Event Execution (Backend-Agnostic)
-  // ============================================================================
-  /**
-   * Execute agent event automations directly (without going through the Claude SDK).
-   * This is the backend-agnostic entry point for non-Claude backends (Codex, Copilot, Pi)
-   * to fire agent events from automations.json.
-   *
-   * For each matching automation matcher, builds env vars and evaluates matching.
-   * Command execution has been removed — all automation actions now go through prompt-based
-   * execution (creating agent sessions via PromptHandler).
-   * Catches all errors — automations must never break the agent flow.
-   *
-   * @param signal - Optional AbortSignal for cancelling automation execution on abort
-   * @returns Number of matched matchers (for diagnostics/testing)
-   */
-  async executeAgentEvent(event, input, signal) {
-    if (!this.config) return 0;
-    const matchers = this.config.automations[event];
-    if (!matchers?.length) return 0;
-    let matchedCount = 0;
-    for (const matcher of matchers) {
-      if (!matcherMatchesSdk(matcher, event, input)) continue;
-      matchedCount++;
-      log8.debug(`[AutomationSystem] Matched ${event} automation (prompt-based execution pending)`);
-    }
-    return matchedCount;
-  }
-  // ============================================================================
-  // SDK Automation Integration
-  // ============================================================================
-  /**
-   * Build SDK hook callbacks from automations.json definitions.
-   *
-   * Command execution has been removed — all automation actions now go through prompt-based
-   * execution (creating agent sessions via PromptHandler). Agent event automations are not
-   * currently supported via prompts, so this returns empty.
-   */
-  buildSdkHooks() {
-    return {};
-  }
-  // ============================================================================
-  // Lifecycle
-  // ============================================================================
-  /**
-   * Check if the system has been disposed.
-   */
-  isDisposed() {
-    return this.disposed;
-  }
-  /**
-   * Dispose the automation system, cleaning up all resources.
-   */
-  async dispose() {
-    if (this.disposed) return;
-    log8.debug(`[AutomationSystem] Disposing for workspace: ${this.options.workspaceId}`);
-    this.stopScheduler();
-    this.promptHandler?.dispose();
-    this.webhookHandler?.dispose();
-    await this.eventLogHandler?.dispose();
-    this.eventBus.dispose();
-    this.lastKnownMetadata.clear();
-    this.disposed = true;
-    log8.debug(`[AutomationSystem] Disposed`);
-  }
-};
-var CURRENCY_PREFIX = /^[$€£¥]/;
-var COMMA_SEPARATOR = /,/g;
-var SUFFIX_MULTIPLIERS = {
-  k: 1e3,
-  m: 1e6,
-  b: 1e9
-};
-function normalizeNumberValue(raw) {
-  let cleaned = raw.trim().replace(CURRENCY_PREFIX, "").replace(COMMA_SEPARATOR, "");
-  const suffixMatch = cleaned.match(/^(-?[\d.]+)([kmb])$/i);
-  if (suffixMatch) {
-    const base = parseFloat(suffixMatch[1]);
-    const multiplier = SUFFIX_MULTIPLIERS[suffixMatch[2].toLowerCase()];
-    const result = base * multiplier;
-    return Number.isInteger(result) ? String(result) : result.toFixed(2);
-  }
-  const num = parseFloat(cleaned);
-  if (isNaN(num)) return raw.trim();
-  return String(num);
-}
-var MAX_MATCHES_PER_MESSAGE = 10;
-var CODE_BLOCK_PATTERN = /```[\s\S]*?```|`[^`]+`/g;
-function evaluateAutoLabels(text, configs) {
-  const stripped = text.replace(CODE_BLOCK_PATTERN, "");
-  const matches = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const config of configs) {
-    for (const rule of config.rules) {
-      if (matches.length >= MAX_MATCHES_PER_MESSAGE) return matches;
-      let flags = rule.flags ?? "gi";
-      if (!flags.includes("g")) flags = `g${flags}`;
-      let regex;
-      try {
-        regex = new RegExp(rule.pattern, flags);
-      } catch {
-        continue;
-      }
-      let match;
-      while ((match = regex.exec(stripped)) !== null) {
-        if (matches.length >= MAX_MATCHES_PER_MESSAGE) return matches;
-        let value;
-        if (rule.valueTemplate) {
-          value = substituteCaptures(rule.valueTemplate, match);
-        } else {
-          value = match[1] ?? match[0];
-        }
-        value = value.trim();
-        if (!value) continue;
-        const dedupeKey = `${config.labelId}::${value}`;
-        if (seen.has(dedupeKey)) continue;
-        seen.add(dedupeKey);
-        matches.push({
-          labelId: config.labelId,
-          value: normalizeNumberValue(value),
-          matchedText: match[0]
-        });
-      }
-    }
-  }
-  return matches;
-}
-function substituteCaptures(template, match) {
-  return template.replace(/\$(\d+)/g, (_, index) => {
-    const i = parseInt(index, 10);
-    return match[i] ?? "";
-  });
-}
-var NESTED_QUANTIFIER = /(\([^)]*[+*][^)]*\))[+*]|\(\?[^)]*[+*][^)]*\)[+*]/;
-function validateAutoLabelPattern(pattern, flags) {
-  const errors = [];
-  const warnings = [];
-  try {
-    new RegExp(pattern, flags ?? "gi");
-  } catch (err) {
-    errors.push(`Invalid regex: ${String(err)}`);
-    return { errors, warnings };
-  }
-  if (NESTED_QUANTIFIER.test(pattern)) {
-    errors.push(`Pattern contains nested quantifiers that may cause catastrophic backtracking: ${pattern}`);
-  }
-  try {
-    const re = new RegExp(pattern, flags ?? "gi");
-    if (!re.global) {
-      warnings.push('Pattern should have the "g" flag to avoid infinite loops');
-    }
-  } catch {
-  }
-  const captureGroupCount = (pattern.match(/\((?!\?)/g) || []).length;
-  if (captureGroupCount === 0) {
-    warnings.push("Pattern has no capture groups \u2014 the entire match will be used as the value");
-  }
-  return { errors, warnings };
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  AGENT_EVENTS,
-  APP_EVENTS,
-  AUTOMATIONS_CONFIG_FILE,
-  AUTOMATIONS_HISTORY_FILE,
-  AUTOMATIONS_RETRY_QUEUE_FILE,
-  AUTOMATION_HISTORY_MAX_ENTRIES,
-  AUTOMATION_HISTORY_MAX_RUNS_PER_MATCHER,
-  AutomationConditionSchema,
-  AutomationEventLogger,
-  AutomationSystem,
-  AutomationsConfigSchema,
-  EventLogHandler,
-  HISTORY_FIELD_MAX_LENGTH,
-  PromptHandler,
-  RetryScheduler,
-  StateConditionSchema,
-  TimeConditionSchema,
-  VALID_EVENTS,
-  WebhookHandler,
-  WorkspaceEventBus,
-  appendAutomationHistoryEntry,
-  automationHistoryInputForPromptResult,
-  buildEnvFromSdkInput,
-  compactAutomationHistory,
-  compactAutomationHistorySync,
-  createAutomationRuntimeGuard,
-  createAutomationSchedulerHost,
-  createAutomationTimelineBridge,
-  createAutomationsConfigDoctorReport,
-  createInMemoryAutomationHistoryStore,
-  createPromptHistoryEntry,
-  createRuntimeAutomationBridge,
-  createWebhookHistoryEntry,
-  evaluateAutoLabels,
-  evaluateConditions,
-  executeAutomationPrompt,
-  executeWebhookRequest,
-  executeWithRetry,
-  extractLabelId,
-  generateShortId,
-  loadAutomationsConfig,
-  matchesCron,
-  normalizeNumberValue,
-  parsePromptReferences,
-  projectTimelineEnvelopeToAutomationInput,
-  resolveAutomationsConfigPath,
-  sanitizeForShell,
-  saveAutomationsConfig,
-  validateAutoLabelPattern,
-  validateAutomations,
-  validateAutomationsConfig,
-  validateAutomationsContent,
-  zodErrorToIssues
-});