evolcore 0.0.4 → 0.0.6

package/dist/core/message/retry-scheduler.js

@@ -0,0 +1,71 @@
+/**
+ * Task-level retry policy. Transport clients may retry an individual HTTP
+ * request, but only this scheduler decides whether the user task is replayed.
+ */
+export const API_RETRY_DELAYS_MS = [5_000, 10_000, 30_000];
+export const MAX_PROTOCOL_REPLAY_ATTEMPTS = 1;
+export class RetryScheduler {
+    resolveModelId;
+    protocolReplayAttempts = 0;
+    apiRetryAttempts = 0;
+    modelFallbackAttempts = 0;
+    attemptedModels = new Set();
+    candidates;
+    constructor(candidates, currentModel, resolveModelId = model => model) {
+        this.resolveModelId = resolveModelId;
+        this.candidates = candidates;
+        if (currentModel)
+            this.attemptedModels.add(this.key(currentModel));
+    }
+    get protocolReplays() {
+        return this.protocolReplayAttempts;
+    }
+    get apiRetryAttemptsMade() {
+        return this.apiRetryAttempts;
+    }
+    shouldTimeoutAttempt() {
+        return this.apiRetryAttempts > 0;
+    }
+    markModelAttempted(model) {
+        this.attemptedModels.add(this.key(model));
+    }
+    afterProtocolFailure(reason, safeToReplay) {
+        if (!reason || !safeToReplay)
+            return { kind: 'none' };
+        if (this.protocolReplayAttempts >= MAX_PROTOCOL_REPLAY_ATTEMPTS)
+            return { kind: 'exhausted' };
+        this.protocolReplayAttempts++;
+        return {
+            kind: 'protocol_replay',
+            attempt: this.protocolReplayAttempts,
+            maxAttempts: MAX_PROTOCOL_REPLAY_ATTEMPTS,
+        };
+    }
+    afterModelUnavailable() {
+        const candidate = this.candidates.find(item => !this.attemptedModels.has(this.key(item.model)));
+        if (!candidate)
+            return { kind: 'exhausted' };
+        this.attemptedModels.add(this.key(candidate.model));
+        this.modelFallbackAttempts++;
+        this.apiRetryAttempts = 0;
+        return {
+            kind: 'model_fallback',
+            candidate,
+            attempt: this.modelFallbackAttempts,
+            candidateCount: this.candidates.length,
+        };
+    }
+    afterTransientFailure(madeProgress) {
+        if (madeProgress)
+            this.apiRetryAttempts = 0;
+        if (this.apiRetryAttempts >= API_RETRY_DELAYS_MS.length)
+            return { kind: 'exhausted' };
+        const attempt = this.apiRetryAttempts + 1;
+        const delayMs = API_RETRY_DELAYS_MS[this.apiRetryAttempts];
+        this.apiRetryAttempts++;
+        return { kind: 'api_retry', attempt, maxAttempts: API_RETRY_DELAYS_MS.length, delayMs };
+    }
+    key(model) {
+        return this.resolveModelId(model).trim().toLowerCase();
+    }
+}

package/dist/core/model/model-catalog.js

@@ -9,7 +9,7 @@
  *
  * 详见 docs/model-command-design.md。
  */
-import { resolveAnthropicConfig, resolveOpenaiConfig } from '../../agents/baseagent.js';
+import { resolveAnthropicConfig, resolveEcagentConfig, resolveOpenaiConfig } from '../../agents/baseagent.js';
 import { activeBaseagent } from './config-scope.js';
 import { resolveEffective } from '../../config/config-manager.js';
 /** 取指定 baseagent 的 baseUrl + apiKey（复用现有解析链）。 */
@@ -24,6 +24,11 @@ function resolveCreds(self, ba) {
             const r = resolveOpenaiConfig({ agents: { codex: c } }, c);
             return { baseUrl: r.baseUrl, apiKey: r.apiKey };
         }
+        if (baseagent === 'ecagent') {
+            const c = block.ecagent;
+            const r = resolveEcagentConfig({ agents: { ecagent: c } }, c);
+            return { baseUrl: r.baseUrl, apiKey: r.apiKey };
+        }
         const c = block.claude;
         const r = resolveAnthropicConfig({ agents: { claude: c } }, c);
         return { baseUrl: r.baseUrl, apiKey: r.apiKey };
@@ -167,7 +172,7 @@ export async function getCatalog(self, ba) {
     const { baseUrl, apiKey } = resolveCreds(self, baseagent);
     if (baseUrl) {
         const base = baseUrl.replace(/\/+$/, '');
-        const v1 = await fetchModelList(`${base}/v1/models`, apiKey);
+        const v1 = await fetchModelList(base.endsWith('/v1') ? `${base}/models` : `${base}/v1/models`, apiKey);
         if (v1)
             return { models: withAliases(v1, baseagent), source: 'v1/models' };
         const plain = await fetchModelList(`${base}/models`, apiKey);

package/dist/core/model/model-fallback.js

@@ -0,0 +1,81 @@
+import { getCodexEfforts } from '../../agents/codex-runner.js';
+import { ConfigTarget, read } from '../../config/config-manager.js';
+export const MAX_FALLBACK_MODELS = 3;
+function isRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function normalizeCandidate(value) {
+    if (!isRecord(value) || typeof value.model !== 'string')
+        return undefined;
+    const model = value.model.trim();
+    if (!model)
+        return undefined;
+    if (value.effort !== undefined && (typeof value.effort !== 'string' || !value.effort.trim()))
+        return undefined;
+    return {
+        model,
+        ...(typeof value.effort === 'string' ? { effort: value.effort.trim() } : {}),
+    };
+}
+/** Read only defaults.json: fallback policy must not participate in H-chain merging. */
+export function configuredFallbackModels(baseagent) {
+    const defaults = read(ConfigTarget.Defaults, undefined, { cache: true });
+    const block = isRecord(defaults?.baseagents) ? defaults.baseagents[baseagent] : undefined;
+    const raw = isRecord(block) ? block.fallbackModels : undefined;
+    if (!Array.isArray(raw))
+        return { candidates: [], rejected: [] };
+    const candidates = [];
+    const rejected = [];
+    for (const [index, value] of raw.entries()) {
+        const candidate = normalizeCandidate(value);
+        if (!candidate) {
+            rejected.push({ reason: 'invalid' });
+            continue;
+        }
+        if (index >= MAX_FALLBACK_MODELS) {
+            rejected.push({ model: candidate.model, reason: 'limit' });
+            continue;
+        }
+        candidates.push(candidate);
+    }
+    return { candidates, rejected };
+}
+function supportsEffort(baseagent, model, effort) {
+    if (!effort)
+        return true;
+    if (baseagent === 'codex')
+        return getCodexEfforts(model).includes(effort);
+    if (baseagent === 'claude')
+        return ['low', 'medium', 'high', 'xhigh', 'max'].includes(effort);
+    if (baseagent === 'ecagent')
+        return ['minimal', 'low', 'medium', 'high', 'xhigh', 'max'].includes(effort);
+    return false;
+}
+export function eligibleFallbackModels(input) {
+    const configured = configuredFallbackModels(input.baseagent);
+    const candidates = [];
+    const rejected = [...configured.rejected];
+    const key = (model) => (input.resolveModelId?.(model) ?? model).trim().toLowerCase();
+    const seen = new Set();
+    if (input.currentModel)
+        seen.add(key(input.currentModel));
+    for (const candidate of configured.candidates) {
+        const resolvedModel = input.resolveModelId?.(candidate.model) ?? candidate.model;
+        const candidateKey = key(candidate.model);
+        if (seen.has(candidateKey)) {
+            rejected.push({ model: candidate.model, reason: candidateKey === key(input.currentModel ?? '') ? 'current_model' : 'duplicate' });
+            continue;
+        }
+        if (!input.isAllowed(resolvedModel)) {
+            rejected.push({ model: candidate.model, reason: 'not_allowed' });
+            continue;
+        }
+        if (!supportsEffort(input.baseagent, resolvedModel, candidate.effort)) {
+            rejected.push({ model: candidate.model, reason: 'unsupported_effort' });
+            continue;
+        }
+        seen.add(candidateKey);
+        candidates.push({ ...candidate, model: resolvedModel });
+    }
+    return { candidates, rejected };
+}

package/dist/core/protected-paths.js

@@ -22,24 +22,28 @@ const H_CLASS_RELATIVE_PATTERNS = [
     /^\.lock$/,
     /^daemon\.pid$/,
     /^data\/causation-aun\.json(?:_|__)?$/,
-    /^data\/message-queue\.json(?:_|__|\.tmp-.*)?$/,
+    /^data\/triggers(?:\/|$)/,
+    /^data\/(?:sessions(?:\/|$)|contact-book-audit\.jsonl$|feishu-seen-.*\.jsonl$|[a-z0-9_-]+-greeted-.*\.jsonl$|message-queue\.json(?:_|__|\.tmp-.*)?$|daemon\/(?:message-queue\.json(?:_|__|\.tmp-.*)?$|control(?:\/|$)|migrations(?:\/|$))|channel-state(?:\/|$))/,
     /^data\/instance\/control\.token$/,
     /^data\/outbox(?:\/|$)/,
     /^data\/handoff(?:\/|$)/,
+    /^agents\/[^/]+\/sessions(?:\/|$)/,
+    /^agents\/[^/]+\/data\/(?:channels(?:\/|$)|handoff(?:\/|$)|outbox\.jsonl(?:_|__|\.tmp-.*)?$|contact-audit\.jsonl$)/,
 ];
 const H_CLASS_REFERENCE_PATTERNS = [
     /(?:^|[^A-Za-z0-9_.-])daemon\.json(?=$|[^A-Za-z0-9_.-])/,
     /(?:^|[^A-Za-z0-9_.-])agents[\\/](?:defaults\.json|[^/\\\s"']+[\\/](?:(?:config|contact)\.json|contact-operations\.jsonl|relations[\\/][^/\\\s"']+[\\/]config\.json))(?=$|[\s"';&|<>)},])/,
     /(?:^|[^A-Za-z0-9_.-])(?:backups[\\/]config|\.snapshots|CA|(?:AIDs|aids)[\\/][^/\\\s"']+[\\/](?:cert|keys))(?:[\\/]|$|[\s"';&|<>)},])/,
-    /(?:^|[/\\\s"'=<>])(?:\.device_id|\.env|\.seed(?:\.[^/\\\s"']*)?|\.migrated-[^/\\\s"']*|\.lock|daemon\.pid|data[\\/](?:causation-aun\.json(?:_|__)?|message-queue\.json(?:_|__|\.tmp-[^/\\\s"']*)?|instance[\\/]control\.token|outbox|handoff))(?:[\\/]|$|[\s"';&|<>)},])/,
+    /(?:^|[/\\\s"'=<>])(?:\.device_id|\.env|\.seed(?:\.[^/\\\s"']*)?|\.migrated-[^/\\\s"']*|\.lock|daemon\.pid|data[\\/](?:causation-aun\.json(?:_|__)?|sessions|contact-book-audit\.jsonl|feishu-seen-[^/\\\s"']+\.jsonl|[a-z0-9_-]+-greeted-[^/\\\s"']+\.jsonl|message-queue\.json(?:_|__|\.tmp-[^/\\\s"']*)?|daemon[\\/](?:message-queue\.json(?:_|__|\.tmp-[^/\\\s"']*)?|control|migrations)|channel-state|instance[\\/]control\.token|outbox|handoff)|agents[\\/][^/\\\s"']+[\\/](?:sessions|data[\\/](?:channels|handoff|outbox\.jsonl|contact-audit\.jsonl)))(?:[\\/]|$|[\s"';&|<>)},])/,
+    /(?:^|[/\\\s"'=<>])data[\\/]triggers(?:[\\/]|$|[\s"';&|<>)},])/,
     /(?:^|[/\\\s"'=<>])(?:[^/\\\s"']+\.json_|[^/\\\s"']+\.json\.migrated|defaults_\d+\.json)(?=$|[\s"';&|<>)},])/,
 ];
 const L_CLASS_RELATIVE_PATTERNS = [
-    /^data\/triggers(?:\/|$)/,
+    /^agents\/[^/]+\/triggers(?:\/|$)/,
     /^agents\/[^/]+\/roles(?:\/|$)/,
 ];
 const L_CLASS_REFERENCE_PATTERNS = [
-    /(?:^|[/\\\s"'=<>])data[\\/]triggers(?:[\\/]|$|[\s"';&|<>)},])/,
+    /(?:^|[^A-Za-z0-9_.-])agents[\\/][^/\\\s"']+[\\/]triggers(?:[\\/]|$|[\s"';&|<>)},])/,
     /(?:^|[^A-Za-z0-9_.-])agents[\\/][^/\\\s"']+[\\/]roles(?:[\\/]|$|[\s"';&|<>)},])/,
 ];
 function normalizeForComparison(value) {
@@ -155,20 +159,34 @@ export function getHClassSandboxPatterns(root = resolveRoot()) {
         '.lock',
         'daemon.pid',
         path.join('data', 'causation-aun.json*'),
+        path.join('data', 'triggers', '**'),
+        path.join('data', 'sessions', '**'),
+        path.join('data', 'contact-book-audit.jsonl'),
+        path.join('data', 'feishu-seen-*.jsonl'),
+        path.join('data', '*-greeted-*.jsonl'),
         path.join('data', 'message-queue.json*'),
+        path.join('data', 'daemon', 'message-queue.json*'),
+        path.join('data', 'daemon', 'control', '**'),
+        path.join('data', 'daemon', 'migrations', '**'),
+        path.join('data', 'channel-state', '**'),
         path.join('data', 'instance', 'control.token'),
         path.join('data', 'outbox'),
         path.join('data', 'outbox', '**'),
         path.join('data', 'handoff'),
         path.join('data', 'handoff', '**'),
+        path.join('agents', '*', 'sessions', '**'),
+        path.join('agents', '*', 'data', 'channels', '**'),
+        path.join('agents', '*', 'data', 'handoff', '**'),
+        path.join('agents', '*', 'data', 'outbox.jsonl*'),
+        path.join('agents', '*', 'data', 'contact-audit.jsonl'),
     ];
     return entries.map(entry => path.join(absoluteRoot, entry));
 }
 export function getLClassWritePatterns(root = resolveRoot()) {
     const absoluteRoot = resolveThroughExistingAncestor(root);
     return [
-        path.join(absoluteRoot, 'data', 'triggers'),
-        path.join(absoluteRoot, 'data', 'triggers', '**'),
+        path.join(absoluteRoot, 'agents', '*', 'triggers'),
+        path.join(absoluteRoot, 'agents', '*', 'triggers', '**'),
         path.join(absoluteRoot, 'agents', '*', 'roles', '**'),
     ];
 }
@@ -190,7 +208,9 @@ export function getExistingHClassMaskTargets(root = resolveRoot()) {
     for (const relative of [
         'daemon.json', 'backups/config', '.snapshots', 'CA',
         '.device_id', '.env', '.seed', '.lock', 'daemon.pid',
-        'data/causation-aun.json', 'data/message-queue.json', 'data/message-queue.json_', 'data/message-queue.json__',
+        'data/causation-aun.json', 'data/sessions', 'data/triggers', 'data/contact-book-audit.jsonl',
+        'data/message-queue.json', 'data/message-queue.json_', 'data/message-queue.json__',
+        'data/daemon/message-queue.json', 'data/daemon/control', 'data/daemon/migrations', 'data/channel-state',
         'data/instance/control.token',
         'data/outbox', 'data/handoff',
     ]) {
@@ -204,6 +224,14 @@ export function getExistingHClassMaskTargets(root = resolveRoot()) {
         }
     }
     catch { }
+    try {
+        for (const entry of fs.readdirSync(path.join(absoluteRoot, 'data'))) {
+            if (/^feishu-seen-.+\.jsonl$/.test(entry) || /^[a-z0-9_-]+-greeted-.+\.jsonl$/i.test(entry)) {
+                addExistingTarget(targets, path.join(absoluteRoot, 'data', entry));
+            }
+        }
+    }
+    catch { }
     const agentsDir = path.join(absoluteRoot, 'agents');
     addExistingTarget(targets, path.join(agentsDir, 'defaults.json'));
     try {
@@ -228,6 +256,11 @@ export function getExistingHClassMaskTargets(root = resolveRoot()) {
                 }
             }
             catch { }
+            addExistingTarget(targets, path.join(agentRoot, 'sessions'));
+            addExistingTarget(targets, path.join(agentRoot, 'data', 'channels'));
+            addExistingTarget(targets, path.join(agentRoot, 'data', 'handoff'));
+            addExistingTarget(targets, path.join(agentRoot, 'data', 'outbox.jsonl'));
+            addExistingTarget(targets, path.join(agentRoot, 'data', 'contact-audit.jsonl'));
         }
     }
     catch { }
@@ -248,12 +281,12 @@ export function getExistingHClassMaskTargets(root = resolveRoot()) {
 export function getExistingLClassReadOnlyTargets(root = resolveRoot()) {
     const targets = new Map();
     const absoluteRoot = resolveThroughExistingAncestor(root);
-    addExistingTarget(targets, path.join(absoluteRoot, 'data', 'triggers'));
     const agentsDir = path.join(absoluteRoot, 'agents');
     try {
         for (const entry of fs.readdirSync(agentsDir, { withFileTypes: true })) {
             if (!entry.isDirectory())
                 continue;
+            addExistingTarget(targets, path.join(agentsDir, entry.name, 'triggers'));
             addExistingTarget(targets, path.join(agentsDir, entry.name, 'roles'));
         }
     }

package/dist/core/session/adapters/ecagent-session-file-adapter.js

@@ -0,0 +1,112 @@
+import fs from 'fs';
+import path from 'path';
+import { agentSessionsDir } from '../../../paths.js';
+function projectDirectory(projectPath, agentAid) {
+    if (!agentAid?.trim())
+        return null;
+    const encoded = path.resolve(projectPath).replace(/^[/\\]/, '').replace(/[/\\:]/g, '-');
+    return path.join(agentSessionsDir(agentAid.trim()), `--${encoded}--`);
+}
+function messageText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    return content
+        .filter((block) => block?.type === 'text' && typeof block.text === 'string')
+        .map(block => block.text)
+        .join('\n');
+}
+function preview(text) {
+    const normalized = text.trim().replace(/\s+/g, ' ');
+    if (!normalized)
+        return null;
+    return normalized.length > 50 ? `${normalized.slice(0, 50)}...` : normalized;
+}
+export class EcagentSessionFileAdapter {
+    baseagent = 'ecagent';
+    findSessionFile(projectPath, agentSessionId, agentAid) {
+        const dir = projectDirectory(projectPath, agentAid);
+        if (!dir)
+            return null;
+        try {
+            const file = fs.readdirSync(dir).find(name => name.endsWith(`_${agentSessionId}.jsonl`));
+            return file ? path.join(dir, file) : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    readEntries(projectPath, agentSessionId, agentAid) {
+        const file = this.findSessionFile(projectPath, agentSessionId, agentAid);
+        if (!file)
+            return [];
+        try {
+            return fs.readFileSync(file, 'utf8').split('\n').slice(1).flatMap(line => {
+                if (!line.trim())
+                    return [];
+                try {
+                    return [JSON.parse(line)];
+                }
+                catch {
+                    return [];
+                }
+            });
+        }
+        catch {
+            return [];
+        }
+    }
+    checkExists(projectPath, agentSessionId, agentAid) {
+        return this.findSessionFile(projectPath, agentSessionId, agentAid) !== null;
+    }
+    getFileInfo(projectPath, agentSessionId, agentAid) {
+        const entries = this.readEntries(projectPath, agentSessionId, agentAid);
+        const userMessages = entries.filter(entry => entry.type === 'message' && entry.message?.role === 'user');
+        const names = entries.filter(entry => entry.type === 'session_info' && typeof entry.name === 'string');
+        const title = names.at(-1)?.name?.trim() || preview(messageText(userMessages[0]?.message?.content));
+        return { turns: userMessages.length, title: title || undefined };
+    }
+    readFirstMessage(projectPath, agentSessionId, agentAid) {
+        const entry = this.readEntries(projectPath, agentSessionId, agentAid)
+            .find(item => item.type === 'message' && item.message?.role === 'user');
+        return preview(messageText(entry?.message?.content));
+    }
+    readLastUserMessage(projectPath, agentSessionId, agentAid) {
+        const entries = this.readEntries(projectPath, agentSessionId, agentAid)
+            .filter(item => item.type === 'message' && item.message?.role === 'user');
+        return preview(messageText(entries.at(-1)?.message?.content));
+    }
+    scanCliSessions(projectPath, _limit = 10, agentAid) {
+        const dir = projectDirectory(projectPath, agentAid);
+        if (!dir)
+            return [];
+        try {
+            return fs.readdirSync(dir)
+                .filter(name => name.endsWith('.jsonl'))
+                .flatMap(name => {
+                const file = path.join(dir, name);
+                try {
+                    const header = JSON.parse(fs.readFileSync(file, 'utf8').split('\n', 1)[0] || '{}');
+                    if (header.type !== 'session' || typeof header.id !== 'string')
+                        return [];
+                    return [{ uuid: header.id, mtime: fs.statSync(file).mtimeMs }];
+                }
+                catch {
+                    return [];
+                }
+            })
+                .sort((a, b) => b.mtime - a.mtime)
+                .slice(0, _limit);
+        }
+        catch {
+            return [];
+        }
+    }
+    async listSdkSessions(projectPath, agentAid) {
+        return this.scanCliSessions(projectPath, 10, agentAid).map(entry => ({
+            sessionId: entry.uuid,
+            title: this.getFileInfo(projectPath, entry.uuid, agentAid).title,
+        }));
+    }
+}