evolcore 0.0.26 → 0.0.27

package/dist/trigger/scheduler.js

@@ -3,7 +3,7 @@ import fs from 'fs';
 import { CronExpressionParser } from 'cron-parser';
 import { logger } from '../utils/logger.js';
 import { matchTriggerEvent, TriggerEventSource } from './event-source.js';
-import { definitionRevision, parseDurationMs, previewText, renderTemplate, resolveScriptPath, sha256, validateConcurrencyCombination, } from './validation.js';
+import { definitionRevision, executionTimeoutMs, parseDurationMs, previewText, renderTemplate, resolveScriptPath, sha256, validateConcurrencyCombination, } from './validation.js';
 import { TargetSessionLockRegistry } from './session-lock.js';
 import { enterTrigger, formatTriggerPath } from '../core/causation/context.js';
 import { createRootCausation } from '../core/causation/context.js';
@@ -13,6 +13,13 @@ const MAX_TIMER_MS = 2_147_483_647;
 const RUN_ABORT_SETTLE_GRACE_MS = 1_000;
 const RUN_COMPLETION_BARRIER_MS = 1_500;
 const TRIGGER_RESTART_RESUME_PROMPT = 'EvolCore 服务已重启。请基于当前会话记录继续完成刚才被中断的 Trigger 任务；不要重新从头执行已经完成的步骤。';
+function eventSessionKey(payload, fallbackAgentAid) {
+    const agentAid = typeof payload.agentAid === 'string' && payload.agentAid.trim()
+        ? payload.agentAid.trim()
+        : fallbackAgentAid;
+    const sessionId = typeof payload.sessionId === 'string' ? payload.sessionId : '';
+    return `${agentAid}:${sessionId}`;
+}
 export class TriggerRuntimeScheduler {
     manager;
     state;
@@ -818,6 +825,7 @@ export class TriggerRuntimeScheduler {
                 attemptId: `${runId}:attempt:${attempt}`,
                 firedAt,
                 prompt,
+                sourcePayload,
                 dryRun,
                 causation,
                 signal,
@@ -869,7 +877,17 @@ export class TriggerRuntimeScheduler {
                 + ` model=${definition.execution.model ?? '<agent-default>'}`
                 + ` effort=${definition.execution.effort ?? '<agent-default>'}`);
             const attemptId = `${runId}:attempt:${attempt}`;
-            const executionDeadlineAt = this.daemonExecutionDeadlineAt(Date.now());
+            const executionStartedAt = Date.now();
+            const configuredExecutionTimeout = executionTimeoutMs(definition.execution);
+            const daemonExecutionDeadlineAt = this.daemonExecutionDeadlineAt(executionStartedAt);
+            const configuredExecutionDeadlineAt = configuredExecutionTimeout === undefined
+                ? undefined
+                : executionStartedAt + configuredExecutionTimeout;
+            const executionDeadlineAt = daemonExecutionDeadlineAt === undefined
+                ? configuredExecutionDeadlineAt
+                : configuredExecutionDeadlineAt === undefined
+                    ? daemonExecutionDeadlineAt
+                    : Math.min(daemonExecutionDeadlineAt, configuredExecutionDeadlineAt);
             const executionSession = await this.daemonChannel.getOrCreateConversationSession(definition, this.runtime.projectPath, runtimeBaseagent, runId, attemptId);
             const activeRun = this.state.startExecutionAttempt?.(definition.id, runId, {
                 attempt,
@@ -963,7 +981,13 @@ export class TriggerRuntimeScheduler {
         });
     }
     async checkConcurrency(definition, nextRunId, source) {
-        const runs = this.running.get(definition.id);
+        const allRuns = this.running.get(definition.id);
+        // An event-session trigger owns many independent sessions. Forbid/replace
+        // applies within the source session, so one failure cannot suppress another.
+        const runs = definition.feedback.strategy === 'event_session' && allRuns
+            ? new Map([...allRuns].filter(([, runtime]) => eventSessionKey(runtime.source.payload, definition.agentAid)
+                === eventSessionKey(source.payload, definition.agentAid)))
+            : allRuns;
         if (!runs || runs.size === 0 || definition.reliability.concurrency === 'allow')
             return undefined;
         const first = runs.values().next().value;
@@ -1753,7 +1777,7 @@ export class TriggerRuntimeScheduler {
     publishTriggerRunOutcome(definition, audit) {
         if (!this.eventBus || audit.status === 'dry-run')
             return;
-        const target = primaryTarget(definition);
+        const target = audit.feedback?.target ?? primaryTarget(definition);
         const targetChannel = target?.channelKey ?? 'daemon';
         const targetChannelId = target?.channelId ?? definition.agentAid;
         const base = {
@@ -2027,6 +2051,8 @@ function summarizeReply(reply, opts = {}) {
 function primaryTarget(definition) {
     if (definition.feedback.strategy === 'target')
         return definition.feedback.target;
+    if (definition.feedback.strategy === 'event_session')
+        return undefined;
     if (!definition.origin)
         return undefined;
     return {

package/dist/trigger/validation.js

@@ -3,6 +3,8 @@ import crypto from 'crypto';
 import { normalizePermissionMode as normalizePermissionModeContract } from '../core/permission/mode.js';
 import { formatChannelKey } from '../core/channel-loader.js';
 const MAX_SCRIPT_TIMEOUT_MS = 900_000;
+const TRIGGER_SESSION_TIMEOUT_MS = 30 * 60_000;
+const MAX_EXECUTION_TIMEOUT_MS = 2_147_483_647;
 export const TRIGGER_SCHEMA_VERSION = 3.1;
 const LEGACY_TRIGGER_SCHEMA_VERSION = 4;
 const DEFAULT_NOOP_SENTINEL = '[[NOOP]]';
@@ -35,7 +37,7 @@ export function normalizeTriggerDefinition(input, opts = {}) {
  * channelId shape inference at runtime.
  */
 export function assertExplicitAunDeliveryRoutes(definition) {
-    if (definition.feedback.strategy === 'silent')
+    if (definition.feedback.strategy === 'silent' || definition.feedback.strategy === 'event_session')
         return;
     const target = definition.feedback.strategy === 'target'
         ? definition.feedback.target
@@ -58,6 +60,11 @@ export function assertExplicitAunDeliveryRoutes(definition) {
 export function validateTriggerDefinition(definition) {
     normalizeTriggerDefinition(definition);
 }
+/** Resolve a model-backed attempt's deadline; target sessions are unlimited by default. */
+export function executionTimeoutMs(execution) {
+    return execution.timeoutMs ?? (execution.type === 'target_session'
+        ? undefined : TRIGGER_SESSION_TIMEOUT_MS);
+}
 /**
  * Keep legacy `per_run` definitions byte-stable while giving runtime code one
  * canonical representation for session selection and validation.
@@ -428,8 +435,14 @@ function normalizeExecution(value, _opts) {
         throw new Error('execution.type must be script, trigger_session, or target_session');
     }
     const thread = normalizeExecutionThread(raw.thread);
+    if (raw.timeoutMs !== undefined && (type === 'script'
+        || typeof raw.timeoutMs !== 'number' || !Number.isSafeInteger(raw.timeoutMs)
+        || raw.timeoutMs <= 0 || raw.timeoutMs > MAX_EXECUTION_TIMEOUT_MS)) {
+        throw new Error('execution.timeoutMs must be an integer between 1 and 2147483647 for a model-backed Trigger');
+    }
     const execution = {
         type,
+        ...(raw.timeoutMs !== undefined ? { timeoutMs: raw.timeoutMs } : {}),
         prompt: type === 'script' ? optionalString(raw.prompt) : requiredString(raw.prompt, 'execution.prompt'),
         script: type === 'script' ? normalizeScript(raw.script) : undefined,
         thread: type === 'trigger_session' ? (thread ?? 'by_trigger') : thread,
@@ -511,8 +524,8 @@ function normalizeFeedback(value, agentAid) {
         throw new Error('feedback must be an object');
     const raw = value;
     const strategy = requiredString(raw.strategy, 'feedback.strategy');
-    if (strategy !== 'origin' && strategy !== 'target' && strategy !== 'silent') {
-        throw new Error('feedback.strategy must be origin, target, or silent');
+    if (strategy !== 'origin' && strategy !== 'target' && strategy !== 'event_session' && strategy !== 'silent') {
+        throw new Error('feedback.strategy must be origin, target, event_session, or silent');
     }
     return {
         strategy,
@@ -630,6 +643,10 @@ function normalizeOnError(value) {
 }
 function validateTriggerSemantics(definition) {
     const execution = definition.execution;
+    if (definition.feedback.strategy === 'event_session'
+        && (definition.source.type !== 'event' || execution.type !== 'target_session')) {
+        throw new Error('feedback.strategy=event_session requires an event source and target_session execution');
+    }
     if (execution.type === 'script') {
         if (!execution.script)
             throw new Error('execution.script is required when execution.type=script');

package/dist/utils/ecweb-utils.js

@@ -70,6 +70,7 @@ export async function fetchRemotePairingCode(authorizedBy) {
     try {
         const response = await ipcQuery(resolvePaths().socket, {
             type: 'remote-auth.pair-code',
+            source: 'host-cli',
             ...(authorizedBy?.trim() ? { authorizedBy: authorizedBy.trim() } : {}),
         }, 2_000);
         if (!response?.ok || typeof response.code !== 'string' || typeof response.expiresAt !== 'number')

package/dist/utils/error-utils.js

@@ -3,6 +3,27 @@ import path from 'path';
 import { getPackageRoot, resolvePaths } from '../paths.js';
 import { logger } from './logger.js';
 import { isSandboxInitializationFailure } from '../core/permission/sandbox-runtime.js';
+/** A deadline imposed by an outer executor, handled by the ordinary task timeout path. */
+export class ExecutionTimeoutError extends Error {
+    reason;
+    timeoutMs;
+    constructor(reason, timeoutMs) {
+        super('TOTAL_EXECUTION_TIMEOUT');
+        this.reason = reason;
+        this.timeoutMs = timeoutMs;
+        this.name = 'ExecutionTimeoutError';
+    }
+}
+export class OrphanedTargetSessionError extends Error {
+    reason = 'orphaned_target_session';
+    constructor() {
+        super('ORPHANED_TARGET_SESSION');
+        this.name = 'OrphanedTargetSessionError';
+    }
+}
+export function isExecutionFailure(error) {
+    return error instanceof ExecutionTimeoutError || error instanceof OrphanedTargetSessionError;
+}
 export const CLAUDE_STARTUP_ARGUMENTS_TOO_LONG = 'claude_startup_arguments_too_long';
 /** A completed provider response exhausted its output budget, rather than a transport failure. */
 export function isOutputTokenLimitError(error) {
@@ -288,7 +309,15 @@ function hasRetryableHttpStatus(text) {
     return RETRYABLE_HTTP_STATUS_PATTERN.test(text);
 }
 export function classifyError(error) {
+    if (error?.code === 'RUNNER_INTERRUPT_UNCONFIRMED')
+        return ErrorType.SESSION_UNAVAILABLE;
     const msg = (error?.message || '').toLowerCase();
+    // A damaged ecagent JSONL transcript is deterministic local state. Retrying
+    // the provider request cannot repair it and can append more entries to the
+    // same unusable file.
+    if (msg.includes('invalid jsonl session file') || msg.includes('invalid session file')) {
+        return ErrorType.SESSION_UNAVAILABLE;
+    }
     // The broad dictionary rule for "stream" must not hide a provider budget limit.
     if (isOutputTokenLimitError(error))
         return ErrorType.MAX_OUTPUT_TOKENS;
@@ -346,11 +375,15 @@ export function classifyError(error) {
  * 注意：401 认证错误不可重试（API Key 无效不会因重试恢复）
  */
 export function isRetryableError(error) {
+    if (error?.code === 'RUNNER_INTERRUPT_UNCONFIRMED')
+        return false;
     // Replaying the same request does not increase its output budget.
     if (isOutputTokenLimitError(error))
         return false;
     const msg = error?.message || String(error);
     const lower = msg.toLowerCase();
+    if (lower.includes('invalid jsonl session file') || lower.includes('invalid session file'))
+        return false;
     // 字典优先 — 命中则直接返回
     const rule = matchErrorRule(lower);
     if (rule)
@@ -366,6 +399,8 @@ export function isRetryableError(error) {
     return false;
 }
 export function getErrorMessage(error, terminalReason, includeEmoji = true) {
+    if (error?.code === 'RUNNER_INTERRUPT_UNCONFIRMED')
+        return `${includeEmoji ? '⚠️ ' : ''}${error.message}`;
     if (terminalReason === 'max_output_tokens' || isOutputTokenLimitError(error)) {
         const prefix = includeEmoji ? '⚠️ ' : '';
         return `${prefix}模型响应达到输出上限（max_output_tokens），本轮未完成。`
@@ -395,7 +430,7 @@ export function getErrorMessage(error, terminalReason, includeEmoji = true) {
             case 'permission_denied':
                 return `${prefix}权限被拒绝，操作已取消`;
             case 'sandbox_initialization_failed':
-                return `${warnPrefix}只读执行沙箱启动失败（sandbox_initialization_failed），当前任务未执行；请检查 user namespace/seccomp 配置后重试`;
+                return `${warnPrefix}执行沙箱启动失败（sandbox_initialization_failed），当前操作未执行；请检查文件系统挂载规则及 user namespace/seccomp 配置`;
             case 'claude_startup_arguments_too_long':
                 return `${warnPrefix}当前 Claude 启动参数过长，任务未执行`;
             case 'aborted_streaming':
@@ -407,6 +442,9 @@ export function getErrorMessage(error, terminalReason, includeEmoji = true) {
     const msg = error?.message || String(error);
     const warnPrefix = includeEmoji ? '⚠️ ' : '';
     const errPrefix = includeEmoji ? '❌ ' : '';
+    if (/invalid (?:jsonl )?session file/i.test(msg)) {
+        return `${errPrefix}ecagent 会话文件损坏，已停止自动重试；请使用 /repair 或 /new 恢复会话`;
+    }
     // Codex app-server reports this when another app-server still owns the
     // thread writer. Surface the handoff condition instead of hiding it behind
     // the generic "processing failed" message.
@@ -429,7 +467,7 @@ export function getErrorMessage(error, terminalReason, includeEmoji = true) {
             : `${warnPrefix}上下文过长，自动压缩失败，请手动输入 /compact 重试`;
     }
     if (isSandboxInitializationFailure(error)) {
-        return `${warnPrefix}只读执行沙箱启动失败（sandbox_initialization_failed），当前任务未执行；请检查 user namespace/seccomp 配置后重试`;
+        return `${warnPrefix}执行沙箱启动失败（sandbox_initialization_failed），当前操作未执行；请检查文件系统挂载规则及 user namespace/seccomp 配置`;
     }
     if (msg.includes('401') || msg.includes('authentication_error') || msg.toLowerCase().includes('unauthorized')) {
         return `${errPrefix}API Key 无效，请检查密钥配置。使用 /status 查看当前配置`;

package/dist/utils/logger.js

@@ -3,7 +3,7 @@ import { resolvePaths } from '../paths.js';
 import { LogWriter } from './log-writer.js';
 import { classifyToolErrorCode, normalizeToolErrorCode } from '../core/permission/tool-error-code.js';
 import { normalizePermissionMode } from '../core/permission/mode.js';
-import { buildToolLifecycleEventKey } from '../core/audit/event-key.js';
+import { buildToolLifecycleEventKey, normalizeToolCorrelation } from '../core/audit/event-key.js';
 let currentLevel = process.env.LOG_LEVEL || 'INFO';
 const LEVELS = { DEBUG: 0, INFO: 1, WARN: 2, ERROR: 3 };
 const config = {
@@ -53,8 +53,18 @@ export function normalizeStructuredLog(data) {
     const nested = data.event && typeof data.event === 'object' ? data.event : undefined;
     const eventType = data.type ?? nested?.type;
     const eventKey = data.eventKey ?? data.event_key ?? nested?.eventKey ?? nested?.event_key;
-    const eventPhase = data.eventPhase ?? data.event_phase ?? nested?.eventPhase ?? nested?.event_phase;
-    const correlationId = data.correlationId
+    const isToolResult = eventType === 'tool:result' || eventType === 'tool_result';
+    const isToolUse = eventType === 'tool:use' || eventType === 'tool_use';
+    const lifecycleRecord = isToolUse || isToolResult;
+    const eventPhase = data.eventPhase ?? data.event_phase ?? nested?.eventPhase ?? nested?.event_phase
+        ?? (isToolUse ? 'use' : isToolResult ? 'result' : undefined);
+    const toolCorrelation = normalizeToolCorrelation({
+        callId: data.callId ?? data.call_id ?? data.toolUseId ?? data.tool_use_id
+            ?? nested?.callId ?? nested?.call_id ?? nested?.toolUseId ?? nested?.tool_use_id,
+        correlationId: data.correlationId ?? data.correlation_id ?? nested?.correlationId ?? nested?.correlation_id,
+        requestId: data.requestId ?? data.request_id ?? nested?.requestId ?? nested?.request_id,
+    });
+    const correlationId = lifecycleRecord ? toolCorrelation.correlationId : data.correlationId
         ?? data.correlation_id
         ?? data.callId
         ?? data.call_id
@@ -69,7 +79,9 @@ export function normalizeStructuredLog(data) {
         ?? nested?.callId
         ?? nested?.call_id
         ?? nested?.toolUseId
-        ?? nested?.tool_use_id;
+        ?? nested?.tool_use_id
+        ?? nested?.requestId
+        ?? nested?.request_id;
     const sessionId = data.sessionId ?? data.session_id ?? nested?.sessionId ?? nested?.session_id;
     const agentAid = data.agentAid ?? data.agent_aid ?? data.selfAid ?? nested?.agentAid ?? nested?.agent_aid ?? nested?.selfAid;
     const rawAgentName = data.agentName ?? data.agent_name ?? nested?.agentName ?? nested?.agent_name;
@@ -91,18 +103,17 @@ export function normalizeStructuredLog(data) {
         ? normalizePermissionMode(rawPermissionMode).mode
         : rawPermissionMode;
     const toolName = data.toolName ?? data.tool ?? data.name ?? nested?.toolName ?? nested?.name;
-    const isToolResult = eventType === 'tool:result' || eventType === 'tool_result';
-    const isToolUse = eventType === 'tool:use' || eventType === 'tool_use';
     const isError = data.isError ?? data.is_error ?? (data.ok === false ? true : undefined)
         ?? nested?.isError ?? nested?.is_error ?? (nested?.ok === false ? true : undefined);
     const decisionSource = data.decisionSource ?? data.decision_source
-        ?? nested?.decisionSource ?? nested?.decision_source;
+        ?? nested?.decisionSource ?? nested?.decision_source
+        ?? (lifecycleRecord ? 'runner' : undefined);
     const decision = data.decision
+        ?? nested?.decision
         ?? data.status
         ?? (isToolResult && isError === true ? 'error' : undefined)
         ?? (isToolResult && isError === false ? 'allow' : undefined)
-        ?? (isToolUse ? 'started' : undefined)
-        ?? nested?.decision;
+        ?? (isToolUse ? 'pending' : undefined);
     const executed = data.executed ?? nested?.executed
         ?? (isToolResult ? true : isToolUse ? false : undefined);
     const executionState = data.executionState ?? data.execution_state
@@ -118,13 +129,10 @@ export function normalizeStructuredLog(data) {
     const classificationMissing = isToolResult && isError === true
         && !normalizeToolErrorCode(explicitErrorCode)
         && decisionSource !== 'policy' && decisionSource !== 'approval';
-    const lifecycleRecord = isToolUse || isToolResult;
     const lifecycleEventKey = lifecycleRecord
         ? (eventKey ?? buildToolLifecycleEventKey({
             sessionId,
-            callId: data.callId ?? data.call_id ?? data.toolUseId ?? data.tool_use_id ?? nested?.callId ?? nested?.call_id,
-            correlationId: data.correlationId ?? data.correlation_id ?? nested?.correlationId ?? nested?.correlation_id,
-            requestId: data.requestId ?? data.request_id ?? nested?.requestId ?? nested?.request_id,
+            ...toolCorrelation,
         }))
         : undefined;
     const missingContextFields = lifecycleRecord
@@ -134,6 +142,8 @@ export function normalizeStructuredLog(data) {
         ...data,
         ...(lifecycleEventKey ? { eventKey: lifecycleEventKey } : {}),
         ...(eventPhase ? { eventPhase } : {}),
+        ...(lifecycleRecord ? toolCorrelation : {}),
+        ...(lifecycleRecord && !toolCorrelation.callId ? { correlationMissing: true } : {}),
         ...(correlationId ? { correlationId } : {}),
         ...(sessionId ? { sessionId } : lifecycleRecord ? { sessionId: 'unknown' } : {}),
         ...(agentAid ? { agentAid } : lifecycleRecord ? { agentAid: 'unknown' } : {}),

package/dist/utils/tool-summary.js

@@ -51,19 +51,75 @@ function displayShellCommand(command) {
     const carrier = resolveCodexShellCarrierString(command);
     return carrier?.dialect === 'powershell' ? carrier.command : undefined;
 }
+/** Hide an initial cd through its first unquoted && or ;, regardless of the directory. */
+function displayBashCommand(command) {
+    const prefix = command.match(/^[ \t]*cd(?=[ \t;]|&&)/);
+    if (!prefix)
+        return command;
+    let quote;
+    for (let index = prefix[0].length; index < command.length; index++) {
+        const char = command[index];
+        if (quote === "'") {
+            if (char === quote)
+                quote = undefined;
+            continue;
+        }
+        if (char === '\\') {
+            index++;
+            continue;
+        }
+        // Nested shell expressions need a full shell parser; keep them visible.
+        if (char === '`' || (char === '$' && command[index + 1] === '('))
+            return command;
+        if (quote === '"') {
+            if (char === quote)
+                quote = undefined;
+            continue;
+        }
+        if (char === "'" || char === '"') {
+            quote = char;
+            continue;
+        }
+        if (char === ';' || (char === '&' && command[index + 1] === '&')) {
+            if (char === ';' && /[;&]/.test(command[index + 1] ?? ''))
+                return command;
+            const body = command.slice(index + (char === ';' ? 1 : 2)).trimStart();
+            return body || command;
+        }
+        // Do not skip over other commands, redirections, or shell comments.
+        if (/[\r\n|&<>()]/.test(char) || (char === '#' && /[ \t]/.test(command[index - 1])))
+            return command;
+    }
+    return command;
+}
 /**
  * Build the tool arguments projected into activity/thought payloads.
  * Execution, permission checks, and audit logging keep using the original
- * input; only the human-facing Shell command is de-wrapped here.
+ * input; only the human-facing command is simplified here.
  */
 export function toolInputForDisplay(toolName, input) {
-    if (!input || toolName !== 'Shell')
+    if (!input || typeof input.command !== 'string')
+        return input;
+    let command;
+    if (toolName === 'Shell') {
+        command = displayShellCommand(input.command) ?? input.command;
+        // Keep explicit shell invocations, but omit standard executable directories.
+        command = command.replace(/^(\s*)(['"]?)\/(?:usr\/)?bin\/(bash|sh)\2(?=\s|$)/, '$1$2$3$2');
+    }
+    else if (toolName === 'Bash') {
+        command = displayBashCommand(input.command);
+    }
+    else {
         return input;
-    const command = displayShellCommand(input.command);
+    }
     if (!command || command === input.command)
         return input;
     return { ...input, command };
 }
+/** Activity summaries use the same command projection as displayed arguments. */
+export function summarizeToolInputForDisplay(toolName, input) {
+    return summarizeToolInput(toolName, toolInputForDisplay(toolName, input) ?? {});
+}
 /**
  * 工具输入摘要（提取工具调用的可读描述，供权限审批和消息展示使用）
  */

package/dist/utils/welcome.js

@@ -8,10 +8,154 @@
  * - 所有 IM 渠道（Feishu/WeChat/DingTalk/QQBot/WeCom）：首次交互时发送给交互用户（被动响应）
  */
 import fs from 'fs';
-import { channelStatePath } from '../paths.js';
+import path from 'path';
+import { createHash } from 'crypto';
+import { parseDocument } from 'yaml';
+import { agentWelcomePath, channelStatePath, resolveRoot } from '../paths.js';
+import { isValidAid } from '../aun/aid/validation.js';
 import { loadAgent, saveAgent } from '../config-store.js';
 import { resolveAgentLifecycle, withLifecycleForWrite } from '../config/lifecycle.js';
+import { renderTemplate } from '../eck/manifest-engine.js';
+import { atomicWriteText } from './atomic-write.js';
 import { logger } from './logger.js';
+export const MAX_WELCOME_TEMPLATE_BYTES = 4 * 1024;
+export const MAX_RENDERED_WELCOME_BYTES = 8 * 1024;
+const WELCOME_TEMPLATE_VARS = new Set([
+    'agentName', 'agentDescription', 'agentAid', 'agentTags', 'agentTagsText',
+    'ownerName', 'ownerAid', 'channel',
+]);
+/** Validate the small, data-only template language used by Bootstrap welcome text. */
+export function validateWelcomeTemplate(template) {
+    const errors = [];
+    if (typeof template !== 'string' || !template.trim()) {
+        return { valid: false, errors: ['welcome template must be non-empty'] };
+    }
+    if (template.includes('\0') || Buffer.from(template, 'utf8').toString('utf8') !== template) {
+        errors.push('welcome template must contain valid UTF-8 text only');
+    }
+    if (Buffer.byteLength(template, 'utf8') > MAX_WELCOME_TEMPLATE_BYTES) {
+        return { valid: false, errors: [`welcome template must be at most ${MAX_WELCOME_TEMPLATE_BYTES} bytes`] };
+    }
+    const stack = [];
+    const tokenPattern = /\{\{|\}\}/g;
+    let match;
+    while ((match = tokenPattern.exec(template)) !== null) {
+        const end = template.indexOf('}}', tokenPattern.lastIndex);
+        if (match[0] !== '{{' || end < 0) {
+            errors.push('unmatched template delimiter');
+            break;
+        }
+        const token = template.slice(tokenPattern.lastIndex, end);
+        tokenPattern.lastIndex = end + 2;
+        if (token === '#each agentTags') {
+            if (stack.includes('each'))
+                errors.push('nested tag loops are not supported');
+            stack.push('each');
+        }
+        else if (token === '/each' || token === '/') {
+            const expected = token === '/each' ? 'each' : 'condition';
+            if (stack.pop() !== expected)
+                errors.push(`unexpected {{${token}}}`);
+        }
+        else if (/^\?\w+$/.test(token) && WELCOME_TEMPLATE_VARS.has(token.slice(1))) {
+            stack.push('condition');
+        }
+        else if ((token === '.' || token === '@index') && stack.includes('each')) {
+            // Loop-local variables are valid only inside the tag loop.
+        }
+        else if (!WELCOME_TEMPLATE_VARS.has(token)) {
+            errors.push(`unsupported template variable or block: ${token}`);
+        }
+        if (stack.length > 8) {
+            errors.push('template blocks are nested too deeply');
+            break;
+        }
+    }
+    if (stack.includes('each'))
+        errors.push('unclosed {{#each}} block');
+    if (stack.includes('condition'))
+        errors.push('unclosed condition block');
+    return { valid: errors.length === 0, errors };
+}
+function checkedWelcomePath(aid) {
+    if (!isValidAid(aid))
+        throw new Error('invalid Agent AID');
+    const target = agentWelcomePath(aid);
+    const root = path.resolve(resolveRoot());
+    for (let cursor = path.resolve(target); cursor !== root; cursor = path.dirname(cursor)) {
+        try {
+            if (fs.lstatSync(cursor).isSymbolicLink())
+                throw new Error('welcome path must not contain symbolic links');
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+    }
+    return target;
+}
+export function saveAgentWelcomeTemplate(aid, template) {
+    const validation = validateWelcomeTemplate(template);
+    if (!validation.valid)
+        throw new Error(`invalid welcome template: ${validation.errors.join('; ')}`);
+    const target = checkedWelcomePath(aid);
+    const staging = target + '.tmp.' + process.pid;
+    try {
+        if (fs.lstatSync(staging).isSymbolicLink())
+            throw new Error('invalid welcome staging path');
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+    try {
+        atomicWriteText(target, template);
+    }
+    finally {
+        fs.rmSync(staging, { force: true });
+    }
+    return { path: target, bytes: Buffer.byteLength(template, 'utf8'), sha256: createHash('sha256').update(template).digest('hex') };
+}
+export function readAgentWelcomeTemplate(aid) {
+    const target = checkedWelcomePath(aid);
+    let stat;
+    try {
+        stat = fs.lstatSync(target);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return null;
+        throw error;
+    }
+    if (!stat.isFile() || stat.size > MAX_WELCOME_TEMPLATE_BYTES)
+        throw new Error('invalid welcome template file');
+    const template = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(fs.readFileSync(target));
+    const validation = validateWelcomeTemplate(template);
+    if (!validation.valid)
+        throw new Error(`invalid welcome template at ${target}: ${validation.errors.join('; ')}`);
+    return template;
+}
+export function parseAgentWelcomeMetadata(content) {
+    const frontmatter = content.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/)?.[1];
+    if (!frontmatter)
+        return { tags: [] };
+    try {
+        const document = parseDocument(frontmatter);
+        if (document.errors.length)
+            return { tags: [] };
+        const value = document.toJS();
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            return { tags: [] };
+        return {
+            name: typeof value.name === 'string' ? value.name.trim() : undefined,
+            description: typeof value.description === 'string' ? value.description.trim() : undefined,
+            tags: Array.isArray(value.tags) ? value.tags.filter((tag) => typeof tag === 'string').map(tag => tag.trim()) : [],
+        };
+    }
+    catch {
+        return { tags: [] };
+    }
+}
 // ============================================================================
 // 欢迎消息生成
 // ============================================================================
@@ -50,6 +194,35 @@ ${agentIntro}${channelInfo}
 
 现在就可以开始工作了！`;
 }
+export function renderPostBootstrapWelcomeMessage(options) {
+    const validation = validateWelcomeTemplate(options.template);
+    if (!validation.valid)
+        throw new Error(`invalid welcome template: ${validation.errors.join('; ')}`);
+    // ECK renders loop bodies recursively. Mask data so names/descriptions containing
+    // template syntax remain literal even when inserted inside a loop or condition.
+    const values = [];
+    const literal = (value) => {
+        if (!value)
+            return '';
+        values.push(value);
+        return `\0WELCOME${values.length - 1}\0`;
+    };
+    const rendered = renderTemplate(options.template, {
+        agentName: literal(options.agentName),
+        agentDescription: literal(options.agentDescription),
+        agentAid: literal(options.agentAid),
+        agentTags: (options.agentTags ?? []).map(literal),
+        agentTagsText: literal((options.agentTags ?? []).join(', ')),
+        ownerName: literal(options.ownerName),
+        ownerAid: literal(options.ownerAid),
+        channel: literal('aun'),
+    }, false).replace(/\0WELCOME(\d+)\0/g, (_match, index) => values[Number(index)]);
+    if (!rendered.trim())
+        throw new Error('welcome template rendered to an empty message');
+    if (Buffer.byteLength(rendered, 'utf8') > MAX_RENDERED_WELCOME_BYTES)
+        throw new Error('rendered welcome exceeds 8192 bytes');
+    return rendered;
+}
 /**
  * 生成简化版欢迎消息（用于快速场景）
  */

package/ecagent/dist/harness/agent-harness.js

@@ -412,6 +412,9 @@ export class AgentHarness {
     }
     async handleAgentEvent(event, signal) {
         if (event.type === "message_end") {
+            // Persist the same multimodal message that was sent to the provider.
+            // Provider rollouts (Claude/Codex) retain image bytes in their own
+            // session files, so ecagent must do the same for resumable context.
             await this.session.appendMessage(event.message);
             await this.emitAny(event, signal);
             return;

package/ecagent/dist/harness/session/jsonl-storage.js

@@ -1,6 +1,25 @@
 import { SessionError, toError } from "../types.js";
 import { getFileSystemResultOrThrow } from "./repo-utils.js";
 import { uuidv7 } from "./uuid.js";
+// Multiple harness instances can briefly reference the same session during a
+// replacement turn. Node's appendFile does not guarantee that large writes
+// from separate calls stay contiguous, so serialize appends per physical file.
+const appendQueues = new Map();
+async function appendSerialized(fs, filePath, content) {
+    const previous = appendQueues.get(filePath) ?? Promise.resolve();
+    let release;
+    const current = new Promise((resolve) => { release = resolve; });
+    appendQueues.set(filePath, current);
+    try {
+        await previous.catch(() => undefined);
+        getFileSystemResultOrThrow(await fs.appendFile(filePath, content), `Failed to append session entry ${filePath}`);
+    }
+    finally {
+        release();
+        if (appendQueues.get(filePath) === current)
+            appendQueues.delete(filePath);
+    }
+}
 function updateLabelCache(labelsById, entry) {
     if (entry.type !== "label")
         return;
@@ -185,7 +204,7 @@ export class JsonlSessionStorage {
             timestamp: new Date().toISOString(),
             targetId: leafId,
         };
-        getFileSystemResultOrThrow(await this.fs.appendFile(this.filePath, `${JSON.stringify(entry)}\n`), `Failed to append session leaf ${entry.id}`);
+        await appendSerialized(this.fs, this.filePath, `${JSON.stringify(entry)}\n`);
         this.entries.push(entry);
         this.byId.set(entry.id, entry);
         this.currentLeafId = leafId;
@@ -194,7 +213,7 @@ export class JsonlSessionStorage {
         return generateEntryId(this.byId);
     }
     async appendEntry(entry) {
-        getFileSystemResultOrThrow(await this.fs.appendFile(this.filePath, `${JSON.stringify(entry)}\n`), `Failed to append session entry ${entry.id}`);
+        await appendSerialized(this.fs, this.filePath, `${JSON.stringify(entry)}\n`);
         this.entries.push(entry);
         this.byId.set(entry.id, entry);
         updateLabelCache(this.labelsById, entry);