evolcore 0.0.1 → 0.0.2

package/dist/trigger/parser.js

@@ -0,0 +1,520 @@
+import { CronExpressionParser } from 'cron-parser';
+const TRIGGER_UPDATE_FLAGS = new Set([
+    'once', 'delay', 'at', 'cron', 'every', 'event', 'tz',
+    'prompt', 'name',
+    'model', 'effort', 'permission',
+    'max-runs', 'max-duration', 'concurrency', 'missed-policy',
+]);
+// Note: unquoted multi-word values (e.g. --prompt=hello world) are not supported.
+// The second word would be treated as an unknown token. Always quote multi-word values:
+//   --prompt "hello world"  or  --prompt='hello world'
+function parseFlags(args) {
+    const flags = new Map();
+    const re = /--(\w[\w-]*)(?:=("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|\S+)|(?:\s+(?!--)("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|\S+))?)?/g;
+    let m;
+    while ((m = re.exec(args)) !== null) {
+        const key = m[1];
+        const val = m[2] ?? m[3];
+        flags.set(key, val === undefined ? true : val.replace(/^["']|["']$/g, ''));
+    }
+    return flags;
+}
+export function parseDuration(s) {
+    const m = /^([1-9]\d*)([dhms])$/.exec(s.trim().toLowerCase());
+    if (!m)
+        return null;
+    const amount = Number(m[1]);
+    const unit = m[2];
+    const multiplier = unit === 'd' ? 86_400_000 : unit === 'h' ? 3_600_000 : unit === 'm' ? 60_000 : 1_000;
+    return amount * multiplier;
+}
+export function parseIsoDate(s) {
+    const d = new Date(s);
+    return isNaN(d.getTime()) ? null : d.getTime();
+}
+export function validateCronExpr(expr) {
+    try {
+        CronExpressionParser.parse(expr);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function parsePositiveIntegerFlag(flags, name, label) {
+    if (!flags.has(name))
+        return { ok: true };
+    const raw = flags.get(name);
+    if (!raw || raw === true)
+        return { ok: false, error: `${label} 不能为空` };
+    if (!/^[1-9]\d*$/.test(raw))
+        return { ok: false, error: `${label} 必须是正整数` };
+    return { ok: true, value: Number(raw) };
+}
+function parseDurationFlag(flags, name, label) {
+    if (!flags.has(name))
+        return { ok: true };
+    const raw = flags.get(name);
+    if (!raw || raw === true)
+        return { ok: false, error: `${label} 不能为空` };
+    const value = parseDuration(raw);
+    if (value === null)
+        return { ok: false, error: `${label} 支持格式：30s、15m、2h、1d` };
+    return { ok: true, value };
+}
+function parseLimitDurationFlag(flags, name, label) {
+    if (!flags.has(name))
+        return { ok: true };
+    const raw = flags.get(name);
+    if (!raw || raw === true)
+        return { ok: false, error: `${label} 不能为空` };
+    if (!/^[1-9]\d*(s|m|h|d)$/.test(raw))
+        return { ok: false, error: `${label} 支持格式：30s、15m、2h、1d` };
+    return { ok: true, value: raw };
+}
+const PERMISSION_MODES = new Set([
+    'readonly',
+    'auto',
+    'request',
+    'bypass',
+]);
+const TRIGGER_EFFORTS = new Set(['low', 'medium', 'high', 'xhigh', 'max']);
+function parsePermissionModeFlag(flags, opts = {}) {
+    if (!flags.has('permission'))
+        return { ok: true };
+    const raw = flags.get('permission');
+    if (!raw || raw === true)
+        return { ok: false, error: '--permission 不能为空' };
+    if (raw === 'inherit') {
+        if (opts.allowInherit)
+            return { ok: true, value: null };
+        return { ok: false, error: '--permission 创建时只能接受 readonly、auto、request 或 bypass' };
+    }
+    if (!PERMISSION_MODES.has(raw)) {
+        return { ok: false, error: '--permission 只接受 readonly、auto、request 或 bypass' };
+    }
+    return { ok: true, value: raw };
+}
+function parseModelFlag(flags) {
+    if (!flags.has('model'))
+        return { ok: true };
+    const raw = flags.get('model');
+    if (!raw || raw === true)
+        return { ok: false, error: '--model 不能为空' };
+    return { ok: true, value: raw };
+}
+function parseEffortFlag(flags) {
+    if (!flags.has('effort'))
+        return { ok: true };
+    const raw = flags.get('effort');
+    if (!raw || raw === true)
+        return { ok: false, error: '--effort 不能为空' };
+    if (!TRIGGER_EFFORTS.has(raw)) {
+        return { ok: false, error: '--effort 只接受 low、medium、high、xhigh 或 max' };
+    }
+    return { ok: true, value: raw };
+}
+function rejectDeprecatedFlags(flags) {
+    if (flags.has('mode'))
+        return '--mode 已废弃，请使用 --exec script|trigger-session|target-session';
+    if (flags.has('session'))
+        return '--session 已废弃，请使用 --feedback/--target-session 或 --trigger-thread';
+    if (flags.has('thread'))
+        return '--thread 已废弃，请使用 --target-thread-id';
+    if (flags.has('script'))
+        return '--script 已废弃，请使用 --exec script --script-path';
+    if (flags.has('runtime'))
+        return '--runtime 已废弃，请使用 --script-runtime';
+    if (flags.has('channel') || flags.has('channelid'))
+        return '--channel/--channelid 已废弃，请使用 --target-channel/--target-channel-id';
+    if (flags.has('chatmode'))
+        return '--chatmode 不支持；trigger chatmode 由运行时按 peerType 强制决定';
+    if (flags.has('activity') || flags.has('show-activities') || flags.has('showActivities')) {
+        return '--activity/--show-activities 不支持；trigger 中间输出由运行时按 peerType 强制决定';
+    }
+    return undefined;
+}
+function parseExecutionType(flags) {
+    if (!flags.has('exec'))
+        return { ok: true };
+    const raw = flags.get('exec');
+    if (!raw || raw === true)
+        return { ok: false, error: '--exec 不能为空' };
+    if (raw === 'script')
+        return { ok: true, value: 'script' };
+    if (raw === 'trigger-session' || raw === 'trigger_session')
+        return { ok: true, value: 'trigger_session' };
+    if (raw === 'target-session' || raw === 'target_session')
+        return { ok: true, value: 'target_session' };
+    return { ok: false, error: '--exec 只接受 script、trigger-session 或 target-session' };
+}
+function parseFeedbackStrategy(flags) {
+    if (!flags.has('feedback'))
+        return { ok: true };
+    const raw = flags.get('feedback');
+    if (!raw || raw === true)
+        return { ok: false, error: '--feedback 不能为空' };
+    if (raw === 'origin' || raw === 'target' || raw === 'silent')
+        return { ok: true, value: raw };
+    return { ok: false, error: '--feedback 只接受 origin、target 或 silent' };
+}
+function parseTriggerThread(flags) {
+    if (!flags.has('trigger-thread'))
+        return { ok: true };
+    const raw = flags.get('trigger-thread');
+    if (!raw || raw === true)
+        return { ok: false, error: '--trigger-thread 不能为空' };
+    if (raw === 'per-run')
+        return { ok: true, value: 'per_run' };
+    if (raw === 'by-trigger')
+        return { ok: true, value: 'by_trigger' };
+    if (raw === 'per_run' || raw === 'by_trigger')
+        return { ok: true, value: raw };
+    return { ok: false, error: '--trigger-thread 只接受 per-run 或 by-trigger' };
+}
+function parseTargetSession(flags) {
+    if (!flags.has('target-session'))
+        return { ok: true };
+    const raw = flags.get('target-session');
+    if (!raw || raw === true)
+        return { ok: false, error: '--target-session 不能为空' };
+    if (raw === 'main' || raw === 'thread')
+        return { ok: true, value: raw };
+    return { ok: false, error: '--target-session 只接受 main 或 thread' };
+}
+function parseSourceFlags(flags, opts = {}) {
+    const hasOnce = flags.has('once');
+    const hasDelay = flags.has('delay');
+    const hasAt = flags.has('at');
+    const hasCron = flags.has('cron');
+    const hasEvery = flags.has('every');
+    const hasEvent = flags.has('event');
+    const count = [hasOnce, hasDelay, hasAt, hasCron, hasEvery, hasEvent].filter(Boolean).length;
+    if (!opts.update && count === 0) {
+        return { ok: false, error: '必须指定触发参数：--once | --delay <时长> | --at <ISO时间> | --cron <表达式> | --every <时长> | --event <事件模式>' };
+    }
+    if (count > 1)
+        return { ok: false, error: '--once、--delay、--at、--cron、--every、--event 互斥，只能指定一个' };
+    if (count === 0)
+        return { ok: true };
+    if (hasOnce)
+        return { ok: true, scheduleType: 'once', scheduleValue: '' };
+    if (hasDelay) {
+        const raw = flags.get('delay');
+        if (!raw || raw === true)
+            return { ok: false, error: '--delay 不能为空' };
+        const ms = parseDuration(raw);
+        if (ms === null)
+            return { ok: false, error: `无法解析 --delay "${raw}"，支持格式：30s、15m、2h、1d` };
+        return { ok: true, scheduleType: 'delay', scheduleValue: String(ms) };
+    }
+    if (hasAt) {
+        const raw = flags.get('at');
+        if (!raw || raw === true)
+            return { ok: false, error: '--at 不能为空' };
+        const ts = parseIsoDate(raw);
+        if (ts === null)
+            return { ok: false, error: `无法解析 --at "${raw}"，请使用 ISO 格式，如 2026-05-15T09:00` };
+        if (!opts.update && ts <= Date.now())
+            return { ok: false, error: `--at 时间已过期：${raw}` };
+        return { ok: true, scheduleType: 'at', scheduleValue: new Date(ts).toISOString() };
+    }
+    if (hasCron) {
+        const raw = flags.get('cron');
+        if (!raw || raw === true)
+            return { ok: false, error: '--cron 不能为空' };
+        if (!validateCronExpr(raw)) {
+            const truncated = /^[\d*/,-]+$/.test(raw) && /--cron\s+\S+\s+[*\d]/.test(String(raw));
+            const hint = truncated ? '（看起来 cron 表达式被空格截断了，请用引号包裹）' : '（需 5 段：分 时 日 月 周，如 */15 * * * *）';
+            return { ok: false, error: `无效的 cron 表达式："${raw}" ${hint}` };
+        }
+        const timezone = flags.has('tz') ? flags.get('tz') : undefined;
+        if (timezone === true)
+            return { ok: false, error: '--tz 不能为空' };
+        return { ok: true, scheduleType: 'cron', scheduleValue: raw, timezone: timezone };
+    }
+    if (hasEvery) {
+        const raw = flags.get('every');
+        if (!raw || raw === true)
+            return { ok: false, error: '--every 不能为空' };
+        const ms = parseDuration(raw);
+        if (ms === null)
+            return { ok: false, error: `无法解析 --every "${raw}"，支持格式：30s、15m、2h、1d` };
+        return { ok: true, scheduleType: 'interval', scheduleValue: String(ms) };
+    }
+    const raw = flags.get('event');
+    if (!raw || raw === true)
+        return { ok: false, error: '--event 不能为空' };
+    return { ok: true, scheduleType: 'event', scheduleValue: raw };
+}
+function commonParsed(flags, opts = {}) {
+    const deprecated = rejectDeprecatedFlags(flags);
+    if (deprecated)
+        return { ok: false, error: deprecated };
+    const source = parseSourceFlags(flags, opts);
+    if (!source.ok)
+        return source;
+    if (flags.has('tz') && source.scheduleType !== 'cron' && (!opts.update || source.scheduleType !== undefined)) {
+        return { ok: false, error: '--tz 只能和 --cron 一起使用' };
+    }
+    const execution = parseExecutionType(flags);
+    if (!execution.ok)
+        return execution;
+    const feedback = parseFeedbackStrategy(flags);
+    if (!feedback.ok)
+        return feedback;
+    const triggerThread = parseTriggerThread(flags);
+    if (!triggerThread.ok)
+        return triggerThread;
+    const targetSession = parseTargetSession(flags);
+    if (!targetSession.ok)
+        return targetSession;
+    const scriptTimeout = parseDurationFlag(flags, 'script-timeout', '--script-timeout');
+    if (!scriptTimeout.ok)
+        return scriptTimeout;
+    const maxRuns = parsePositiveIntegerFlag(flags, 'max-runs', '--max-runs');
+    if (!maxRuns.ok)
+        return maxRuns;
+    const maxDuration = parseLimitDurationFlag(flags, 'max-duration', '--max-duration');
+    if (!maxDuration.ok)
+        return maxDuration;
+    const model = parseModelFlag(flags);
+    if (!model.ok)
+        return model;
+    const effort = parseEffortFlag(flags);
+    if (!effort.ok)
+        return effort;
+    const permissionMode = parsePermissionModeFlag(flags, { allowInherit: opts.update });
+    if (!permissionMode.ok)
+        return permissionMode;
+    let scriptArgs;
+    if (flags.has('script-args')) {
+        const raw = flags.get('script-args');
+        if (!raw || raw === true)
+            return { ok: false, error: '--script-args 不能为空' };
+        try {
+            scriptArgs = JSON.parse(raw);
+        }
+        catch {
+            return { ok: false, error: '--script-args 必须是合法的 JSON' };
+        }
+    }
+    const prompt = flags.get('prompt');
+    if (prompt === true)
+        return { ok: false, error: '--prompt 不能为空' };
+    if (typeof prompt === 'string' && prompt.length > 4096)
+        return { ok: false, error: '--prompt 超过 4096 字符限制' };
+    const scriptPath = flags.get('script-path');
+    if (scriptPath === true)
+        return { ok: false, error: '--script-path 不能为空' };
+    const scriptRuntime = flags.get('script-runtime');
+    if (scriptRuntime === true)
+        return { ok: false, error: '--script-runtime 不能为空' };
+    if (scriptRuntime !== undefined && scriptRuntime !== 'node' && scriptRuntime !== 'python' && scriptRuntime !== 'bash') {
+        return { ok: false, error: '--script-runtime 只接受 node、python 或 bash' };
+    }
+    const targetChannel = flags.get('target-channel');
+    if (targetChannel === true)
+        return { ok: false, error: '--target-channel 不能为空' };
+    const targetChannelId = flags.get('target-channel-id');
+    if (targetChannelId === true)
+        return { ok: false, error: '--target-channel-id 不能为空' };
+    const targetThreadId = flags.get('target-thread-id');
+    if (targetThreadId === true)
+        return { ok: false, error: '--target-thread-id 不能为空' };
+    const hasTargetField = targetChannel !== undefined || targetChannelId !== undefined || targetSession.value !== undefined || targetThreadId !== undefined;
+    if ((targetChannel === undefined) !== (targetChannelId === undefined)) {
+        return { ok: false, error: '--target-channel 与 --target-channel-id 必须同时指定或同时省略' };
+    }
+    const inferredExecution = execution.value ?? (scriptPath ? 'script' : 'target_session');
+    if (inferredExecution === 'script') {
+        if (!scriptPath && !opts.update)
+            return { ok: false, error: '--exec script 需要 --script-path' };
+        if (scriptPath && !scriptRuntime && !opts.update)
+            return { ok: false, error: '--script-path 必须配合 --script-runtime 使用（node|python|bash）' };
+    }
+    else if (!prompt && !opts.update) {
+        return { ok: false, error: '--prompt 为必填项' };
+    }
+    const targetSessionValue = targetSession.value ?? (targetThreadId ? 'thread' : 'main');
+    const feedbackStrategy = feedback.value ?? (hasTargetField ? 'target' : 'origin');
+    return {
+        ok: true,
+        value: {
+            ...source,
+            executionType: execution.value,
+            inferredExecution,
+            feedbackStrategy,
+            targetChannel: targetChannel,
+            targetChannelId: targetChannelId,
+            targetSession: targetSessionValue,
+            targetThreadId: targetThreadId,
+            agentId: flags.has('agent') ? flags.get('agent') : undefined,
+            name: flags.has('name') ? flags.get('name') : undefined,
+            prompt: prompt,
+            scriptPath: scriptPath,
+            scriptRuntime: scriptRuntime,
+            scriptArgs,
+            scriptTimeoutMs: scriptTimeout.value,
+            triggerThread: triggerThread.value,
+            maxRuns: maxRuns.value,
+            maxDuration: maxDuration.value,
+            model: model.value,
+            effort: effort.value,
+            permissionMode: permissionMode.value,
+        },
+    };
+}
+export function parseTriggerSet(args) {
+    const flags = parseFlags(args);
+    const parsed = commonParsed(flags);
+    if (!parsed.ok)
+        return parsed;
+    const value = parsed.value;
+    return {
+        ok: true,
+        value: {
+            scheduleType: value.scheduleType,
+            scheduleValue: value.scheduleValue ?? '',
+            timezone: value.timezone,
+            executionType: value.inferredExecution,
+            feedbackStrategy: value.feedbackStrategy,
+            targetChannel: value.targetChannel,
+            targetChannelId: value.targetChannelId,
+            targetSession: value.targetSession,
+            targetThreadId: value.targetThreadId,
+            agentId: value.agentId,
+            name: value.name,
+            prompt: value.prompt,
+            scriptPath: value.scriptPath,
+            scriptRuntime: value.scriptRuntime,
+            scriptArgs: value.scriptArgs,
+            scriptTimeoutMs: value.scriptTimeoutMs,
+            triggerThread: value.triggerThread,
+            maxRuns: value.maxRuns,
+            maxDuration: value.maxDuration,
+            model: value.model,
+            effort: value.effort,
+            permissionMode: value.permissionMode,
+        },
+    };
+}
+export function parseTriggerUpdate(args) {
+    const trimmed = args.trim();
+    if (!trimmed)
+        return { ok: false, error: '用法：/trigger update <名称|ID> [--参数...]' };
+    let nameOrId;
+    let rest;
+    if (trimmed.startsWith('"') || trimmed.startsWith("'")) {
+        const quote = trimmed[0];
+        const end = trimmed.indexOf(quote, 1);
+        if (end === -1)
+            return { ok: false, error: '名称引号未闭合' };
+        nameOrId = trimmed.slice(1, end);
+        rest = trimmed.slice(end + 1).trim();
+    }
+    else {
+        const spaceIdx = trimmed.indexOf(' ');
+        if (spaceIdx === -1)
+            return { ok: false, error: '至少需要指定一个修改参数（如 --prompt、--delay、--event 等）' };
+        nameOrId = trimmed.slice(0, spaceIdx);
+        rest = trimmed.slice(spaceIdx + 1).trim();
+    }
+    if (!rest)
+        return { ok: false, error: '至少需要指定一个修改参数（如 --prompt、--delay、--event 等）' };
+    const flags = parseFlags(rest);
+    return parseTriggerUpdateFlags(nameOrId, flags);
+}
+export function parseTriggerUpdateArgv(nameOrId, args) {
+    const flags = new Map();
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (!arg.startsWith('--'))
+            return { ok: false, error: `无法识别 update 参数: ${arg}` };
+        const equals = arg.indexOf('=');
+        if (equals > 2) {
+            flags.set(arg.slice(2, equals), arg.slice(equals + 1));
+            continue;
+        }
+        const key = arg.slice(2);
+        const next = args[i + 1];
+        if (next !== undefined && !next.startsWith('--')) {
+            flags.set(key, next);
+            i += 1;
+        }
+        else {
+            flags.set(key, true);
+        }
+    }
+    return parseTriggerUpdateFlags(nameOrId, flags);
+}
+function parseTriggerUpdateFlags(nameOrId, flags) {
+    if (flags.size === 0)
+        return { ok: false, error: '至少需要指定一个修改参数（如 --prompt、--delay、--event 等）' };
+    for (const flag of flags.keys()) {
+        if (!TRIGGER_UPDATE_FLAGS.has(flag))
+            return { ok: false, error: `update 不支持参数 --${flag}` };
+    }
+    const parsed = commonParsed(flags, { update: true });
+    if (!parsed.ok)
+        return parsed;
+    const value = parsed.value;
+    const update = {};
+    if (value.scheduleType !== undefined)
+        update.scheduleType = value.scheduleType;
+    if (value.scheduleValue !== undefined)
+        update.scheduleValue = value.scheduleValue;
+    if (value.timezone !== undefined)
+        update.timezone = value.timezone;
+    if (flags.has('tz') && update.timezone === undefined) {
+        const timezone = optionalFlagString(flags, 'tz');
+        if ('error' in timezone)
+            return { ok: false, error: timezone.error };
+        if (timezone.value !== undefined)
+            update.timezone = timezone.value;
+    }
+    if (value.name !== undefined)
+        update.name = value.name;
+    if (value.prompt !== undefined)
+        update.prompt = value.prompt;
+    if (value.model !== undefined)
+        update.model = value.model;
+    if (value.effort !== undefined)
+        update.effort = value.effort;
+    if (value.permissionMode !== undefined)
+        update.permissionMode = value.permissionMode;
+    if (value.maxRuns !== undefined)
+        update.maxRuns = value.maxRuns;
+    if (value.maxDuration !== undefined)
+        update.maxDuration = value.maxDuration;
+    const concurrency = optionalFlagString(flags, 'concurrency');
+    if ('error' in concurrency)
+        return { ok: false, error: concurrency.error };
+    if (concurrency.value !== undefined) {
+        if (concurrency.value !== 'forbid' && concurrency.value !== 'replace' && concurrency.value !== 'allow') {
+            return { ok: false, error: '--concurrency 只接受 forbid、replace 或 allow' };
+        }
+        update.concurrency = concurrency.value;
+    }
+    const missedPolicy = optionalFlagString(flags, 'missed-policy');
+    if ('error' in missedPolicy)
+        return { ok: false, error: missedPolicy.error };
+    if (missedPolicy.value !== undefined) {
+        const normalized = missedPolicy.value.replace('-', '_');
+        if (normalized !== 'skip' && normalized !== 'run_once' && normalized !== 'run_all') {
+            return { ok: false, error: '--missed-policy 只接受 skip、run-once 或 run-all' };
+        }
+        update.missedPolicy = normalized;
+    }
+    if (Object.keys(update).length === 0)
+        return { ok: false, error: '没有可更新的 trigger 参数' };
+    return { ok: true, nameOrId, value: update };
+}
+function optionalFlagString(flags, name) {
+    if (!flags.has(name))
+        return {};
+    const raw = flags.get(name);
+    if (raw === true)
+        return { error: `--${name} 不能为空` };
+    return { value: raw };
+}

package/dist/trigger/patch.js

@@ -0,0 +1,148 @@
+import { normalizeTriggerDefinition, parseDurationMs, TRIGGER_SCHEMA_VERSION } from './validation.js';
+const PATCH_KEYS = new Set([
+    'name',
+    'scheduleType',
+    'scheduleValue',
+    'timezone',
+    'prompt',
+    'model',
+    'effort',
+    'permissionMode',
+    'maxRuns',
+    'maxDuration',
+    'concurrency',
+    'missedPolicy',
+]);
+export function applyTriggerPatch(definition, input) {
+    if (!input || typeof input !== 'object' || Array.isArray(input)) {
+        throw new Error('trigger patch must be an object');
+    }
+    const patch = input;
+    const keys = Object.keys(patch);
+    if (keys.length === 0)
+        throw new Error('trigger patch must contain at least one field');
+    for (const key of keys) {
+        if (!PATCH_KEYS.has(key))
+            throw new Error(`trigger update does not support field: ${key}`);
+    }
+    const updated = JSON.parse(JSON.stringify(definition));
+    if (patch.name !== undefined)
+        updated.name = String(patch.name);
+    applySourcePatch(updated, patch);
+    if (patch.prompt !== undefined) {
+        if (updated.execution.type === 'script')
+            updated.feedback.onReply = { template: String(patch.prompt) };
+        else
+            updated.execution.prompt = String(patch.prompt);
+    }
+    if (patch.model !== undefined)
+        setOptional(updated.execution, 'model', patch.model);
+    if (patch.effort !== undefined)
+        setOptional(updated.execution, 'effort', patch.effort);
+    if (patch.permissionMode !== undefined)
+        setOptional(updated.execution, 'permissionMode', patch.permissionMode);
+    if (patch.concurrency !== undefined)
+        updated.reliability.concurrency = patch.concurrency;
+    if (patch.missedPolicy !== undefined)
+        updated.reliability.missedPolicy = patch.missedPolicy;
+    if (patch.maxRuns !== undefined || patch.maxDuration !== undefined) {
+        const limits = updated.limits ? { ...updated.limits } : {};
+        if (patch.maxRuns !== undefined) {
+            if (patch.maxRuns === null)
+                delete limits.maxRuns;
+            else
+                limits.maxRuns = patch.maxRuns;
+        }
+        if (patch.maxDuration !== undefined) {
+            if (patch.maxDuration === null || patch.maxDuration === '')
+                delete limits.maxDuration;
+            else
+                limits.maxDuration = patch.maxDuration;
+        }
+        updated.limits = Object.keys(limits).length > 0 ? limits : undefined;
+    }
+    return normalizeTriggerDefinition({
+        ...updated,
+        id: definition.id,
+        agentAid: definition.agentAid,
+        createdAt: definition.createdAt,
+        updatedAt: definition.updatedAt,
+        ...(definition.origin ? { origin: definition.origin } : {}),
+    });
+}
+/**
+ * Replaces the editable Trigger V3.1 definition while keeping lifecycle and
+ * ownership fields under server control. This is the ECWeb structured-edit
+ * path; the compact CLI patch path above remains intentionally limited.
+ */
+export function replaceEditableTriggerDefinition(existing, input) {
+    if (!input || typeof input !== 'object' || Array.isArray(input)) {
+        throw new Error('trigger definition update must be an object');
+    }
+    const editable = input;
+    return normalizeTriggerDefinition({
+        ...editable,
+        $schema_version: TRIGGER_SCHEMA_VERSION,
+        id: existing.id,
+        agentAid: existing.agentAid,
+        enabled: existing.enabled,
+        createdAt: existing.createdAt,
+        updatedAt: existing.updatedAt,
+        origin: existing.origin,
+    });
+}
+function applySourcePatch(updated, patch) {
+    const previous = updated.source;
+    if (patch.scheduleType !== undefined || patch.scheduleValue !== undefined) {
+        const current = scheduleView(previous);
+        const type = patch.scheduleType ?? current.type;
+        const value = patch.scheduleValue ?? current.value;
+        const next = sourceFromSchedule(type, value);
+        if (next.type === 'cron' && previous.type === 'cron' && patch.timezone === undefined) {
+            next.timezone = previous.timezone;
+        }
+        if (next.type === 'event' && previous.type === 'event')
+            next.filter = previous.filter;
+        updated.source = next;
+    }
+    if (patch.timezone !== undefined) {
+        if (updated.source.type !== 'cron')
+            throw new Error('timezone is only valid for a cron trigger');
+        if (patch.timezone === null || patch.timezone === '')
+            delete updated.source.timezone;
+        else
+            updated.source.timezone = String(patch.timezone);
+    }
+}
+function sourceFromSchedule(type, value) {
+    switch (type) {
+        case 'once': return { type: 'once' };
+        case 'delay': return { type: 'delay', afterMs: durationMs(value) };
+        case 'at': return { type: 'at', at: value };
+        case 'cron': return { type: 'cron', expression: value };
+        case 'interval': return { type: 'interval', everyMs: durationMs(value) };
+        case 'event': return { type: 'event', eventPattern: value };
+    }
+}
+function scheduleView(source) {
+    switch (source.type) {
+        case 'once': return { type: 'once', value: '' };
+        case 'delay': return { type: 'delay', value: String(source.afterMs) };
+        case 'at': return { type: 'at', value: source.at };
+        case 'cron': return { type: 'cron', value: source.expression };
+        case 'interval': return { type: 'interval', value: String(source.everyMs) };
+        case 'event': return { type: 'event', value: source.eventPattern };
+    }
+}
+function durationMs(value) {
+    const numeric = Number(value);
+    if (Number.isFinite(numeric) && numeric > 0)
+        return numeric;
+    return parseDurationMs(value);
+}
+function setOptional(object, key, value) {
+    if (value === null || value === '')
+        delete object[key];
+    else
+        object[key] = value;
+}