evolcore 0.0.32 → 0.0.34

package/dist/core/session/session-idle-monitor.js

@@ -1,25 +1,142 @@
 import fs from 'fs';
 import path from 'path';
-import { ConfigTarget, read as readConfig } from '../../config/config-manager.js';
+import { ConfigTarget, mutateConfig, read as readConfig } from '../../config/config-manager.js';
 import { formatPeerKey } from '../relation/peer-identity.js';
+import { isSystemControlChannel } from '../system-channels.js';
 import { logger } from '../../utils/logger.js';
 import { atomicWriteJson } from './session-fs-store.js';
 import { createRootCausation } from '../causation/context.js';
-export const MIN_SESSION_IDLE_SECONDS = 30;
-export function readRelationSessionIdleSeconds(session) {
-    if (!session.selfAID || !session.channelId)
+export const DEFAULT_SESSION_LOOP_SECONDS = 300;
+export const MIN_SESSION_LOOP_SECONDS = 30;
+export const MAX_SESSION_LOOP_SECONDS = 86400;
+export function normalizeSessionLoopConfig(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
         return undefined;
-    try {
-        const relation = readConfig(ConfigTarget.Relation, {
-            self: session.selfAID,
-            peerKey: formatPeerKey(session.channelType || session.channel, session.channelId),
-        }, { cache: true, expand: true });
-        return relation?.sessionIdleSec;
-    }
-    catch (error) {
-        logger.warn(`[SessionIdleMonitor] Failed to read relation config for ${session.id}: ${error instanceof Error ? error.message : String(error)}`);
+    const raw = value;
+    if (Object.keys(raw).some(key => key !== 'enabled' && key !== 'idleSeconds'))
+        return undefined;
+    if (raw.enabled === false && Object.keys(raw).every(key => key === 'enabled'))
+        return { enabled: false };
+    if (raw.enabled !== true || !isValidIdleSeconds(raw.idleSeconds))
+        return undefined;
+    return { enabled: true, idleSeconds: raw.idleSeconds };
+}
+export function validateIdleSeconds(value) {
+    return isValidIdleSeconds(value) ? value : undefined;
+}
+export function resolveSessionLoopTarget(session) {
+    if (!session || session.deletedAt || session.topicStatus === 'archived'
+        || session.metadata?.sessionType || isSystemControlChannel(session.channel)
+        || (session.chatType !== 'private' && session.chatType !== 'group'))
+        return undefined;
+    const peerId = session.chatType === 'group'
+        ? session.metadata?.groupId || session.channelId
+        : session.channelId;
+    if (!session.selfAID || !peerId)
         return undefined;
+    const peerKey = formatPeerKey(session.channelType || session.channel, peerId);
+    return { level: session.threadId ? 'topic-session' : 'relation-main', session, peerKey };
+}
+export function readSessionLoopConfig(target) {
+    let value;
+    if (target.level === 'topic-session')
+        value = target.session.metadata?.sessionLoop;
+    else {
+        try {
+            const relation = readConfig(ConfigTarget.Relation, {
+                self: target.session.selfAID,
+                peerKey: target.peerKey,
+            }, { cache: true, expand: true });
+            value = relation?.sessionLoop;
+        }
+        catch (error) {
+            logger.warn(`[SessionLoop] Failed to read configuration for ${target.session.id}; disabled: ${error instanceof Error ? error.message : String(error)}`);
+            return undefined;
+        }
+    }
+    const config = normalizeSessionLoopConfig(value);
+    if (value !== undefined && !config)
+        logger.warn(`[SessionLoop] Invalid configuration for ${target.session.id}; disabled`);
+    return config;
+}
+export function readSessionLoopConfigForSession(session) {
+    const target = resolveSessionLoopTarget(session);
+    return target ? readSessionLoopConfig(target) : undefined;
+}
+export function updateRelationSessionLoop(session, config) {
+    const target = resolveSessionLoopTarget(session);
+    if (!target || target.level !== 'relation-main')
+        throw sessionLoopError('INVALID_TARGET', 'relation main session is required');
+    const selector = { self: session.selfAID, peerKey: target.peerKey };
+    const normalized = normalizeSessionLoopConfig(config);
+    if (!normalized)
+        throw sessionLoopError('INVALID_ARGUMENT', 'invalid sessionLoop configuration');
+    mutateConfig(ConfigTarget.Relation, selector, current => {
+        current.sessionLoop = normalized;
+    });
+}
+export async function resolveCurrentSessionLoopTarget(store, route) {
+    let session;
+    try {
+        session = route.threadId
+            ? await store.getThreadSession(route.channel, route.channelId, route.threadId)
+            : await store.getActiveSession(route.channel, route.channelId);
+    }
+    catch {
+        throw sessionLoopError('SESSION_LOOKUP_FAILED', '无法读取当前会话，拒绝回退到其他会话');
+    }
+    if (!session || session.deletedAt)
+        throw sessionLoopError(route.threadId ? 'NOT_FOUND' : 'NO_ACTIVE_SESSION', '当前会话不存在');
+    const target = resolveSessionLoopTarget(session);
+    if (!target || !route.selfAid || session.selfAID !== route.selfAid
+        || session.channel !== route.channel || session.channelId !== route.channelId
+        || (session.threadId || '') !== (route.threadId || '')) {
+        throw sessionLoopError('INVALID_CONTEXT', '当前会话路由或归属不匹配');
+    }
+    return target;
+}
+export async function refreshSessionLoopTarget(store, route, expected) {
+    const current = await resolveCurrentSessionLoopTarget(store, route);
+    if (current.session.id !== expected.session.id || current.peerKey !== expected.peerKey || current.level !== expected.level) {
+        throw sessionLoopError('CONFLICT', '当前会话已发生变化，请重新查询');
     }
+    return current;
+}
+export function writeSessionLoopConfig(store, target, config) {
+    if (target.level === 'topic-session') {
+        const session = store.updateSessionLoop(target.session.id, config);
+        return { ...target, session };
+    }
+    const active = store.getActiveSessionSync(target.session.channel, target.session.channelId);
+    if (!active || active.deletedAt || active.id !== target.session.id || active.threadId) {
+        throw sessionLoopError('CONFLICT', '当前主会话已发生变化，请重新查询');
+    }
+    updateRelationSessionLoop(active, config);
+    return { ...target, session: active };
+}
+export function sessionLoopPayload(target) {
+    const config = readSessionLoopConfig(target);
+    return {
+        target: { level: target.level, sessionId: target.session.id },
+        sessionId: target.session.id,
+        value: config?.enabled === true,
+        ...(config?.enabled ? { idleSeconds: config.idleSeconds } : {}),
+    };
+}
+export function sessionLoopError(code, message) {
+    return Object.assign(new Error(message), { code });
+}
+function isValidIdleSeconds(value) {
+    return typeof value === 'number'
+        && Number.isFinite(value)
+        && Number.isSafeInteger(value)
+        && value >= MIN_SESSION_LOOP_SECONDS
+        && value <= MAX_SESSION_LOOP_SECONDS;
+}
+export const MIN_SESSION_IDLE_SECONDS = MIN_SESSION_LOOP_SECONDS;
+export function readSessionLoopIdleSeconds(session) {
+    const config = readSessionLoopConfigForSession(session);
+    return config?.enabled ? config.idleSeconds : undefined;
 }
 /**
  * Publishes one session:idle event after a runner task ends, using the
@@ -71,7 +188,17 @@ export class SessionIdleMonitor {
         if (event.type !== 'session:switched')
             return;
         this.clearSession(event.fromSessionId);
-        this.clearSession(event.toSessionId);
+        void this.activateMainSession(event.toSessionId);
+    };
+    onSessionCreated = (event) => {
+        if (event.type !== 'session:created' || event.threadId)
+            return;
+        for (const sessionId of this.sessions.keys())
+            void this.pruneInactiveMainSession(sessionId);
+    };
+    onSessionLoopChanged = (event) => {
+        if (event.type === 'session:loop-changed')
+            void this.refreshSession(event.sessionId, event.timestamp);
     };
     constructor(options) {
         this.options = options;
@@ -88,6 +215,8 @@ export class SessionIdleMonitor {
         this.options.eventBus.subscribe('task:started', this.onTaskStarted);
         this.options.eventBus.subscribe('session:deleted', this.onSessionDeleted);
         this.options.eventBus.subscribe('session:switched', this.onSessionSwitched);
+        this.options.eventBus.subscribe('session:created', this.onSessionCreated);
+        this.options.eventBus.subscribe('session:loop-changed', this.onSessionLoopChanged);
     }
     /** Arm restored timers only after event-trigger subscriptions are registered. */
     activate() {
@@ -108,6 +237,47 @@ export class SessionIdleMonitor {
             this.scheduleSession(sessionId);
         }
     }
+    async refreshSession(sessionId, changedAt = this.now()) {
+        const state = this.sessions.get(sessionId);
+        if (!state || !this.active)
+            return;
+        const generation = this.generations.get(sessionId) ?? 0;
+        try {
+            const session = await this.options.getSessionById(sessionId);
+            if (!session || !this.isEligibleSession(session))
+                return;
+            const seconds = await this.readIdleSeconds(session);
+            if (this.sessions.get(sessionId) !== state || (this.generations.get(sessionId) ?? 0) !== generation)
+                return;
+            if (state.idleSeconds === seconds)
+                return;
+            this.clearTimers(sessionId);
+            this.generations.set(sessionId, generation + 1);
+            state.idleSeconds = seconds;
+            state.armedAt = changedAt;
+            state.emitted = false;
+            this.persistState();
+            if (seconds !== undefined && !await this.options.isSessionBusy(sessionId))
+                this.scheduleSession(sessionId);
+        }
+        catch (error) {
+            this.warn(`Failed to refresh loop configuration for ${sessionId}`, error);
+        }
+    }
+    async refreshRelation(selfAid, peerKey, changedAt = this.now()) {
+        for (const sessionId of this.sessions.keys()) {
+            try {
+                const session = await this.options.getSessionById(sessionId);
+                const target = resolveSessionLoopTarget(session);
+                if (target?.level === 'relation-main' && target.peerKey === peerKey && session?.selfAID === selfAid) {
+                    await this.refreshSession(sessionId, changedAt);
+                }
+            }
+            catch (error) {
+                this.warn(`Failed to refresh relation loop configuration for ${sessionId}`, error);
+            }
+        }
+    }
     stop() {
         this.active = false;
         this.clearAllTimers();
@@ -120,6 +290,8 @@ export class SessionIdleMonitor {
         this.options.eventBus.unsubscribe('task:started', this.onTaskStarted);
         this.options.eventBus.unsubscribe('session:deleted', this.onSessionDeleted);
         this.options.eventBus.unsubscribe('session:switched', this.onSessionSwitched);
+        this.options.eventBus.unsubscribe('session:created', this.onSessionCreated);
+        this.options.eventBus.unsubscribe('session:loop-changed', this.onSessionLoopChanged);
     }
     now() {
         return this.options.now?.() ?? Date.now();
@@ -172,15 +344,21 @@ export class SessionIdleMonitor {
             this.clearSession(sessionId);
             return;
         }
-        if (!isSupportedSession(session))
+        if (!this.isEligibleSession(session)) {
+            this.clearTimers(sessionId);
             return;
+        }
         const idleSeconds = await this.readIdleSeconds(session);
         if (!this.isCurrentCycle(sessionId, state.lastEndedAt, generation))
             return;
+        if (this.timers.has(sessionId))
+            return;
         const idleMs = toIdleMs(idleSeconds);
+        state.idleSeconds = idleSeconds;
+        this.persistState();
         if (idleMs === undefined)
             return;
-        const delay = Math.max(0, state.lastEndedAt + idleMs - this.now());
+        const delay = Math.max(0, (state.armedAt ?? state.lastEndedAt) + idleMs - this.now());
         const timer = setTimeout(() => {
             this.timers.delete(sessionId);
             void this.emitIfIdle(sessionId, state.lastEndedAt, generation);
@@ -209,14 +387,14 @@ export class SessionIdleMonitor {
             this.clearSession(sessionId);
             return;
         }
-        if (!isSupportedSession(session))
+        if (!this.isEligibleSession(session))
             return;
         const idleMs = toIdleMs(await this.readIdleSeconds(session));
         if (!this.isCurrentCycle(sessionId, lastEndedAt, generation))
             return;
         if (idleMs === undefined)
             return;
-        const remaining = lastEndedAt + idleMs - this.now();
+        const remaining = (this.sessions.get(sessionId)?.armedAt ?? lastEndedAt) + idleMs - this.now();
         if (remaining > 0) {
             this.scheduleSession(sessionId);
             return;
@@ -232,6 +410,8 @@ export class SessionIdleMonitor {
         }
         if (!this.isCurrentCycle(sessionId, lastEndedAt, generation))
             return;
+        if (!this.isEligibleSession(session))
+            return;
         if (busy) {
             // An active/queued task is not idle. Disarm this cycle and let its next
             // terminal event start a fresh one; repeatedly rearming here would poll
@@ -248,7 +428,8 @@ export class SessionIdleMonitor {
         if (!state || state.emitted)
             return;
         state.emitted = true;
-        this.persistState();
+        if (!this.persistState())
+            return;
         this.options.eventBus.publish({
             type: 'session:idle',
             sessionId,
@@ -308,6 +489,49 @@ export class SessionIdleMonitor {
             return undefined;
         }
     }
+    isEligibleSession(session) {
+        return !!resolveSessionLoopTarget(session)
+            && (!!session.threadId || !this.options.isCurrentMainSession || this.options.isCurrentMainSession(session));
+    }
+    async disarmMainSession(sessionId) {
+        try {
+            const session = await this.options.getSessionById(sessionId);
+            if (!session || session.threadId)
+                return;
+            this.clearTimers(sessionId);
+            this.generations.set(sessionId, (this.generations.get(sessionId) ?? 0) + 1);
+        }
+        catch (error) {
+            this.warn(`Failed to disarm main session ${sessionId}`, error);
+        }
+    }
+    async activateMainSession(sessionId) {
+        try {
+            const session = await this.options.getSessionById(sessionId);
+            const state = this.sessions.get(sessionId);
+            if (!session || session.threadId || !state || !this.isEligibleSession(session))
+                return;
+            this.clearTimers(sessionId);
+            this.generations.set(sessionId, (this.generations.get(sessionId) ?? 0) + 1);
+            state.armedAt = this.now();
+            state.emitted = false;
+            this.persistState();
+            this.scheduleSession(sessionId);
+        }
+        catch (error) {
+            this.warn(`Failed to activate main session ${sessionId}`, error);
+        }
+    }
+    async pruneInactiveMainSession(sessionId) {
+        try {
+            const session = await this.options.getSessionById(sessionId);
+            if (session && !session.threadId && !this.isEligibleSession(session))
+                await this.disarmMainSession(sessionId);
+        }
+        catch (error) {
+            this.warn(`Failed to inspect main session ${sessionId}`, error);
+        }
+    }
     loadState() {
         try {
             if (!fs.existsSync(this.options.statePath))
@@ -330,6 +554,8 @@ export class SessionIdleMonitor {
                     lastEndedAt,
                     emitted,
                     ...(typeof rawState.encrypted === 'boolean' ? { encrypted: rawState.encrypted } : {}),
+                    ...(typeof rawState.armedAt === 'number' && Number.isFinite(rawState.armedAt) ? { armedAt: rawState.armedAt } : {}),
+                    ...(typeof rawState.idleSeconds === 'number' ? { idleSeconds: rawState.idleSeconds } : {}),
                 });
             }
         }
@@ -344,23 +570,24 @@ export class SessionIdleMonitor {
                 lastEndedAt: state.lastEndedAt,
                 emitted: state.emitted,
                 ...(typeof state.encrypted === 'boolean' ? { encrypted: state.encrypted } : {}),
+                ...(state.armedAt !== undefined ? { armedAt: state.armedAt } : {}),
+                ...(state.idleSeconds !== undefined ? { idleSeconds: state.idleSeconds } : {}),
             };
         }
         try {
             fs.mkdirSync(path.dirname(this.options.statePath), { recursive: true });
             atomicWriteJson(this.options.statePath, { version: 2, sessions });
+            return true;
         }
         catch (error) {
             this.warn(`Failed to persist session idle state at ${this.options.statePath}`, error);
+            return false;
         }
     }
     warn(message, error) {
         logger.warn(`[SessionIdleMonitor] ${message}${error === undefined ? '' : `: ${error instanceof Error ? error.message : String(error)}`}`);
     }
 }
-function isSupportedSession(session) {
-    return session.chatType === 'group' || session.chatType === 'private';
-}
 function toIdleMs(seconds) {
     if (seconds === undefined || !Number.isFinite(seconds) || seconds <= 0)
         return undefined;

package/dist/core/session/session-manager.js

@@ -1,10 +1,11 @@
+import { normalizeSessionLoopConfig, resolveSessionLoopTarget, sessionLoopError } from './session-idle-monitor.js';
 import { ensureDir } from '../../utils/atomic-write.js';
 import { resolvePaths } from '../../paths.js';
 import { logger } from '../../utils/logger.js';
 import { encodePath } from '../../utils/cross-platform.js';
 import { readRunnerEventSummary } from './runner-event-summary.js';
 import { isInternalInjectedUserMessage, isToolResultMessage } from './session-transcript.js';
-import { chatDirPath, generateSessionId, formatTimestamp, atomicWriteJson, atomicWriteText, appendJsonl, appendJsonlDurable, fsyncJsonlFile, readJsonFile, readLastJsonlLine, readLastJsonlLineStrict, readAllJsonlLines, scanChatDirs, scanMetaFiles, ensureChatDir, readThreadIndex, writeThreadIndex, } from './session-fs-store.js';
+import { chatDirPath, generateSessionId, formatTimestamp, atomicWriteJson, atomicWriteText, appendJsonl, appendJsonlDurable, fsyncJsonlFile, readJsonFile, readLastJsonlLine, readLastJsonlLineStrict, readAllJsonlLines, scanChatDirs, scanMetaFiles, ensureChatDir, readThreadIndex, writeThreadIndex, compactJsonlTail, SESSION_META_COMPACT_POLICY, } from './session-fs-store.js';
 import { sessionToFile, fileToSession, formatSessionKey, DEFAULT_THREAD_ID, normalizeTopicLabel, normalizeTopicStatus, } from './session-mapper.js';
 import { tryParseChannelKey } from '../channel-loader.js';
 import { isSystemControlChannel } from '../system-channels.js';
@@ -225,7 +226,7 @@ export function pageForkHistory(snapshot, before = snapshot.items.length, limit
     };
 }
 /** Metadata keys owned by ordinary topic/session routing writers. */
-const TOPIC_METADATA_PROTECTED_KEYS = new Set(['turnState', 'resumeAt', 'agentSessions']);
+const TOPIC_METADATA_PROTECTED_KEYS = new Set(['turnState', 'resumeAt', 'agentSessions', 'sessionLoop']);
 const TOPIC_BACKEND_SCOPED_KEYS = ['resumeAt', 'agentSessions'];
 function topicMetadataOwnershipError(key) {
     const error = new Error(`topic metadata field is owned by a dedicated updater: ${key}`);
@@ -260,6 +261,9 @@ export class SessionManager {
     identityResolver;
     fileAdapters = new Map();
     sessionEncryptState = new Map();
+    /** findSessionFileById 的查找缓存：命中前一律 stat 校验，不作为真相源。 */
+    sessionFileIndex = new Map();
+    knownChatDirs = null;
     constructor(sessionsDir, eventBus, identityResolver) {
         ensureDir(sessionsDir);
         this.sessionsDir = sessionsDir;
@@ -626,6 +630,13 @@ export class SessionManager {
             appendJsonlDurable(metaPath, file);
         else
             appendJsonl(metaPath, file);
+        // 本次快照已落盘；压缩只回收历史行，失败不影响写入结果，原文件保持不变。
+        try {
+            compactJsonlTail(metaPath, SESSION_META_COMPACT_POLICY);
+        }
+        catch (error) {
+            logger.warn(`[SessionManager] meta compaction skipped for ${metaPath}: ${error instanceof Error ? error.message : String(error)}`);
+        }
     }
     /**
      * Session 持久化的唯一事务原语。所有 session 写操作都应经此，业务层不直接调
@@ -646,6 +657,15 @@ export class SessionManager {
      * @returns 是否真的写入了 .jsonl（去重命中时返回 false）
      */
     persistSession(session, intent, opts) {
+        if (!opts?.sessionLoopMutation) {
+            const latest = this.readMetaLatest(this.metaPathForSession(session));
+            const metadata = { ...(session.metadata ?? {}) };
+            if (latest?.metadata?.sessionLoop !== undefined)
+                metadata.sessionLoop = latest.metadata.sessionLoop;
+            else
+                delete metadata.sessionLoop;
+            session.metadata = metadata;
+        }
         // Topic session snapshots can be written by synchronous legacy paths
         // (mark/clear processing) after an async /renew has committed.  Preserve
         // the newest backend fence unless this call is one of the two explicit
@@ -807,24 +827,84 @@ export class SessionManager {
         }
         return results;
     }
+    /**
+     * 按 sessionId 定位 meta 文件。逐个 id 全量 scanChatDirs 在几百个 chat 目录下
+     * 单次约 50ms，启动时批量查询（SessionIdleMonitor 恢复 170+ 会话）会同步阻塞数秒，
+     * 所以首次查询时按 readdir 建一份 id→路径索引，之后：
+     *   - 命中：stat 校验仍在才返回（文件被移进 _trash/目录被迁移时自然失效）；
+     *   - 未命中：先在已知目录里按原规则 stat 探测（覆盖索引之后新建的会话），
+     *     再重扫目录列表、只探测新出现的目录。不存在的 id 开销与原实现相当。
+     * 目录顺序与「同目录先主文件后 _threads」的优先级保持原实现语义。
+     */
     findSessionFileById(sessionId) {
-        const chatDirs = scanChatDirs(this.sessionsDir);
-        for (const { dirPath } of chatDirs) {
+        const cached = this.sessionFileIndex.get(sessionId);
+        if (cached) {
+            try {
+                fs.statSync(cached.metaPath);
+                return cached;
+            }
+            catch {
+                this.sessionFileIndex.delete(sessionId);
+            }
+        }
+        if (!this.knownChatDirs) {
+            this.rebuildSessionFileIndex();
+            const indexed = this.sessionFileIndex.get(sessionId);
+            if (indexed)
+                return indexed;
+        }
+        const probed = this.probeSessionFile(sessionId, this.knownChatDirs);
+        if (probed)
+            return probed;
+        const previous = new Set(this.knownChatDirs);
+        this.knownChatDirs = scanChatDirs(this.sessionsDir).map(entry => entry.dirPath);
+        return this.probeSessionFile(sessionId, this.knownChatDirs.filter(dir => !previous.has(dir)));
+    }
+    probeSessionFile(sessionId, chatDirs) {
+        for (const dirPath of chatDirs) {
             const mainPath = path.join(dirPath, `${sessionId}.jsonl`);
             try {
                 fs.statSync(mainPath);
-                return { chatDir: dirPath, metaPath: mainPath, isThread: false };
+                return this.rememberSessionFile(sessionId, { chatDir: dirPath, metaPath: mainPath, isThread: false });
             }
             catch { }
             const threadPath = path.join(dirPath, '_threads', `${sessionId}.jsonl`);
             try {
                 fs.statSync(threadPath);
-                return { chatDir: dirPath, metaPath: threadPath, isThread: true };
+                return this.rememberSessionFile(sessionId, { chatDir: dirPath, metaPath: threadPath, isThread: true });
             }
             catch { }
         }
         return undefined;
     }
+    rememberSessionFile(sessionId, found) {
+        this.sessionFileIndex.set(sessionId, found);
+        return found;
+    }
+    rebuildSessionFileIndex() {
+        this.sessionFileIndex.clear();
+        this.knownChatDirs = scanChatDirs(this.sessionsDir).map(entry => entry.dirPath);
+        for (const dirPath of this.knownChatDirs) {
+            for (const [dir, isThread] of [[dirPath, false], [path.join(dirPath, '_threads'), true]]) {
+                let names;
+                try {
+                    names = fs.readdirSync(dir);
+                }
+                catch {
+                    continue;
+                }
+                for (const name of names) {
+                    if (!name.endsWith('.jsonl'))
+                        continue;
+                    const id = name.slice(0, -'.jsonl'.length);
+                    // 先到先得：与逐目录探测时的优先级一致。
+                    if (!this.sessionFileIndex.has(id)) {
+                        this.sessionFileIndex.set(id, { chatDir: dirPath, metaPath: path.join(dir, name), isThread });
+                    }
+                }
+            }
+        }
+    }
     // ─── Public API ───
     getKnownThreadIds(channel) {
         const chatDirs = scanChatDirs(this.sessionsDir);
@@ -1308,6 +1388,8 @@ export class SessionManager {
         if (updates.name !== undefined)
             current.name = updates.name;
         if (updates.metadata !== undefined) {
+            if (Object.hasOwn(updates.metadata, 'sessionLoop'))
+                throw topicMetadataOwnershipError('sessionLoop');
             if (current.threadId) {
                 for (const key of Object.keys(updates.metadata)) {
                     if (TOPIC_METADATA_PROTECTED_KEYS.has(key))
@@ -1337,6 +1419,8 @@ export class SessionManager {
             return;
         const { current } = loaded;
         for (const key of Object.keys(patch)) {
+            if (key === 'sessionLoop')
+                throw topicMetadataOwnershipError(key);
             if (current.threadId && TOPIC_METADATA_PROTECTED_KEYS.has(key)) {
                 throw topicMetadataOwnershipError(key);
             }
@@ -1351,6 +1435,21 @@ export class SessionManager {
         current.metadata = metadata;
         this.persistSession(current, 'sync');
     }
+    updateSessionLoop(sessionId, config) {
+        const normalized = normalizeSessionLoopConfig(config);
+        if (!normalized)
+            throw sessionLoopError('INVALID_ARGUMENT', 'invalid sessionLoop configuration');
+        return this.mutateLatestTopicSession(sessionId, current => {
+            const target = resolveSessionLoopTarget(current);
+            if (!target || target.level !== 'topic-session')
+                throw sessionLoopError('INVALID_CONTEXT', '话题会话不存在或已不可用');
+            current.metadata = { ...(current.metadata ?? {}), sessionLoop: normalized };
+            const changed = this.persistSession(current, 'none', { sessionLoopMutation: true });
+            if (changed)
+                this.eventBus.publish({ type: 'session:loop-changed', sessionId, timestamp: Date.now() });
+            return current;
+        });
+    }
     /** Persist only the turn coordinator-owned metadata field. */
     async updateTurnState(sessionId, turnState) {
         const loaded = this.loadSessionForUpdate(sessionId);
@@ -1366,6 +1465,8 @@ export class SessionManager {
         this.persistSession(current, 'sync', { turnStateMutation: true });
     }
     getOrCreateThreadSession(channel, channelId, threadId, defaultProjectPath, metadata, name, baseagent, selfAID, channelType, peerType, chatType, label, topicStatus) {
+        const topicMetadata = { ...(metadata ?? {}) };
+        delete topicMetadata.sessionLoop;
         // 使用精确路径（channelType + selfAID）
         const chatDir = (channelType && selfAID)
             ? (() => { const d = chatDirPath(this.sessionsDir, channelType, channelId, selfAID, channel); fs.mkdirSync(d, { recursive: true }); fs.mkdirSync(path.join(d, '_threads'), { recursive: true }); return d; })()
@@ -1387,7 +1488,7 @@ export class SessionManager {
                 let mutated = false;
                 if (metadata) {
                     const creatorPeerId = existing.metadata?.peerId;
-                    existing.metadata = { ...(existing.metadata || {}), ...metadata };
+                    existing.metadata = { ...(existing.metadata || {}), ...topicMetadata };
                     if (creatorPeerId && existing.metadata)
                         existing.metadata.peerId = creatorPeerId;
                     mutated = true;
@@ -1411,7 +1512,21 @@ export class SessionManager {
         const mainActive = readJsonFile(path.join(chatDir, 'active.json'));
         // 兼容旧字段名
         const mainBaseagent = mainActive?.baseagent || mainActive?.agentType;
-        const inheritedBaseagent = mainBaseagent || baseagent;
+        // 最终兜底：从 agent config.json 读 active_baseagent（宿主终端下 active.json 可能不存在）
+        const configBaseagent = (() => {
+            if (mainBaseagent || baseagent)
+                return undefined;
+            if (!selfAID)
+                return undefined;
+            try {
+                const cfg = readJsonFile(path.join(resolvePaths().agentsDir, selfAID, 'config.json'));
+                return cfg?.active_baseagent || undefined;
+            }
+            catch {
+                return undefined;
+            }
+        })();
+        const inheritedBaseagent = mainBaseagent || baseagent || configBaseagent;
         if (!inheritedBaseagent) {
             throw new Error('[SessionManager] getOrCreateThreadSession: baseagent is empty');
         }
@@ -1426,7 +1541,7 @@ export class SessionManager {
             baseagent: inheritedBaseagent,
             sessionKey,
             chatType: effectiveChatType,
-            metadata,
+            metadata: topicMetadata,
             name: name || '话题会话',
             label: normalizeTopicLabel(label),
             topicStatus: topicStatus ? normalizeTopicStatus(topicStatus) : 'pending',
@@ -1671,10 +1786,10 @@ export class SessionManager {
             return !!session && !session.threadId;
         });
     }
-    async getThreadSession(channel, channelId, threadId) {
+    async getThreadSession(channel, channelId, threadId, selfAID) {
         let chatDir;
         try {
-            chatDir = this.resolveChatDirSafe(channel, channelId);
+            chatDir = this.resolveChatDirSafe(channel, channelId, channel === 'aun' ? 'aun' : undefined, selfAID);
         }
         catch {
             return undefined;
@@ -1687,9 +1802,6 @@ export class SessionManager {
         const session = this.readMetaLatest(metaPath);
         if (!session)
             return undefined;
-        // Do not consult provider-file existence to derive topic binding state;
-        // the topic JSONL boundary is authoritative and may intentionally point
-        // at a backend that needs an explicit /renew or repair operation.
         const validSessionId = normalizeBackendSessionId(session.agentSessionId);
         return { ...session, agentSessionId: validSessionId };
     }
@@ -1761,6 +1873,8 @@ export class SessionManager {
         return target;
     }
     updateMetadata(sessionId, metadata) {
+        if (Object.hasOwn(metadata, 'sessionLoop'))
+            throw topicMetadataOwnershipError('sessionLoop');
         const loaded = this.loadSessionForUpdate(sessionId);
         if (!loaded)
             return;
@@ -2123,6 +2237,7 @@ export class SessionManager {
         delete metadata.agentSessions;
         delete metadata.resumeAt;
         delete metadata.replyContext;
+        delete metadata.sessionLoop;
         metadata.__sessionRenewedAt = Date.now();
         const session = {
             id: generateSessionId(),

package/dist/core/skill/command-parser.js

@@ -0,0 +1,13 @@
+import { isValidAid } from '../../aun/aid/validation.js';
+export function resolveSkillRefreshArgv(argv) {
+    if (argv[0] !== 'skill' || argv[1] !== 'refresh' || argv.length < 3 || argv.length > 4
+        || argv.some(value => typeof value !== 'string'))
+        throw new Error('Invalid skill refresh argv');
+    const positional = argv.slice(2).filter(value => value !== '--json');
+    if (positional.length !== 1)
+        throw new Error('Specify one Agent AID');
+    const aid = positional[0].replace(/^@/, '');
+    if (!isValidAid(aid))
+        throw new Error('Invalid Agent AID');
+    return aid;
+}