mocode-ai 1.4.2 → 1.4.3

package/dist/session/scheduler.js

@@ -2,8 +2,7 @@
 // rewritten only after real occupancy reaches the shared pressure threshold.
 import { evaluateBudget, scheduleActions, formatReport, DEFAULT_BUDGET_POLICY, } from '../context/budget.js';
 import { chatTools } from '../llm/index.js';
-import { config } from '../config/index.js';
-import { maybeCompact, contextState } from './compact.js';
+import { defaultCompactionRuntime, maybeCompact, contextState, } from './compact.js';
 import { pruneStaleArtifacts, refreshArtifactFreshness } from '../context/artifacts.js';
 import { pruneSuperseded } from '../context/relevance.js';
 import { createAgeAwareEncodingState } from '../context/age-aware.js';
@@ -21,8 +20,8 @@ function emptyPressure(report) {
     };
 }
 /** One scheduler instance is owned by one agent run. */
-export function createBudgetScheduler(state = contextState) {
-    const evaluate = (history, step, activeTools, ephemeralTokens) => evaluateBudget(history, config.contextWindowTokens, step, state.correction, activeTools, ephemeralTokens);
+export function createBudgetScheduler(state = contextState, runtime = defaultCompactionRuntime) {
+    const evaluate = (history, step, activeTools, ephemeralTokens) => evaluateBudget(history, runtime.config.contextWindowTokens, step, state.correction, activeTools, ephemeralTokens);
     const scheduler = {
         lastRunLog: null,
         async runStep(history, step, activeTools = chatTools, ephemeralTokens = 0, signal) {
@@ -35,11 +34,11 @@ export function createBudgetScheduler(state = contextState) {
                 // A single 80% pressure event owns every history rewrite. Run all enabled
                 // low-cost cleanup first, then always compact; do not introduce per-stage
                 // thresholds or stop early when one stage happens to cross below 80%.
-                if (config.contextRelprune) {
+                if (runtime.config.contextRelprune) {
                     pressure.superseded = pruneSuperseded(history, report.hotBoundary);
                 }
                 pressure.staleArtifacts = pruneStaleArtifacts(state, history, report.hotBoundary);
-                if (config.contextOptimize) {
+                if (runtime.config.contextOptimize) {
                     const ageAware = createAgeAwareEncodingState(history);
                     pressure.encodedLogsAndSearches = ageAware.sweepPressure(history, report.hotBoundary);
                 }
@@ -50,10 +49,12 @@ export function createBudgetScheduler(state = contextState) {
             const actions = scheduleActions(report);
             let compactHistoryCalled = false;
             let historyRebuilt = false;
+            let contentMutated = pressure.superseded > 0 || pressure.staleArtifacts > 0 || pressure.encodedLogsAndSearches > 0;
             for (const _action of actions) {
-                const result = await maybeCompact(history, report, undefined, state, activeTools, signal);
+                const result = await maybeCompact(history, report, undefined, state, activeTools, signal, runtime);
                 compactHistoryCalled = true;
                 historyRebuilt ||= result?.historyRebuilt === true;
+                contentMutated ||= result?.compacted === true;
             }
             const log = {
                 step,
@@ -61,6 +62,7 @@ export function createBudgetScheduler(state = contextState) {
                 actions,
                 pressure,
                 compactHistoryCalled,
+                historyMutation: historyRebuilt ? 'rebuild' : contentMutated ? 'content' : 'none',
                 ts: Date.now(),
             };
             scheduler.lastRunLog = log;
@@ -70,28 +72,35 @@ export function createBudgetScheduler(state = contextState) {
     };
     return scheduler;
 }
-export async function runScheduler(history, step, state = contextState, activeTools = chatTools) {
-    return createBudgetScheduler(state).runStep(history, step, activeTools);
+export async function runScheduler(history, step, state = contextState, activeTools = chatTools, runtime = defaultCompactionRuntime) {
+    return createBudgetScheduler(state, runtime).runStep(history, step, activeTools);
 }
 /** User-requested compaction bypasses automatic pressure gating. */
 export async function manualCompact(history, focus, opts) {
     const signal = opts?.signal;
-    if (config.contextBudget === false) {
+    const runtime = opts?.runtime ?? defaultCompactionRuntime;
+    const state = opts?.contextState ?? contextState;
+    const activeTools = opts?.activeTools ?? chatTools;
+    if (runtime.config.contextBudget === false) {
         const result = await import('./compact.js').then(({ compactHistory }) => compactHistory(history, {
-            window: config.contextWindowTokens,
+            window: runtime.config.contextWindowTokens,
             threshold: DEFAULT_BUDGET_POLICY.pressureTriggerRatio,
             focus,
             manual: true,
             force: opts?.force,
+            tools: activeTools,
+            contextState: state,
+            runtime,
             signal,
         }));
-        const report = evaluateBudget(history, config.contextWindowTokens, -1, contextState.correction);
+        const report = evaluateBudget(history, runtime.config.contextWindowTokens, -1, state.correction, activeTools);
         const log = {
             step: -1,
             report,
             actions: [{ kind: 'compact_history', focus }],
             pressure: emptyPressure(report),
             compactHistoryCalled: true,
+            historyMutation: result.historyRebuilt ? 'rebuild' : result.compacted ? 'content' : 'none',
             ts: Date.now(),
             compactDetail: {
                 reason: result.reason,
@@ -102,10 +111,10 @@ export async function manualCompact(history, focus, opts) {
                 focus,
             },
         };
-        contextState.schedulerLog = log;
+        state.schedulerLog = log;
         return log;
     }
-    const report = evaluateBudget(history, config.contextWindowTokens, -1, contextState.correction);
+    const report = evaluateBudget(history, runtime.config.contextWindowTokens, -1, state.correction, activeTools);
     let actions = scheduleActions(report);
     if (!actions.some((action) => action.kind === 'compact_history')) {
         actions = [...actions, { kind: 'compact_history', focus }];
@@ -114,6 +123,7 @@ export async function manualCompact(history, focus, opts) {
         actions = actions.map((action) => (action.kind === 'compact_history' ? { ...action, focus } : action));
     }
     let compactHistoryCalled = false;
+    let historyMutation = 'none';
     let compactDetail;
     for (const action of actions) {
         if (action.kind !== 'compact_history')
@@ -122,9 +132,10 @@ export async function manualCompact(history, focus, opts) {
             manual: true,
             force: opts?.force,
             focus: action.focus,
-        }, contextState, chatTools, signal);
+        }, state, activeTools, signal, runtime);
         compactHistoryCalled = true;
         if (result) {
+            historyMutation = result.historyRebuilt ? 'rebuild' : result.compacted ? 'content' : historyMutation;
             compactDetail = {
                 reason: result.reason,
                 estimateBefore: result.estimateBefore,
@@ -141,10 +152,11 @@ export async function manualCompact(history, focus, opts) {
         actions,
         pressure: emptyPressure(report),
         compactHistoryCalled,
+        historyMutation,
         ts: Date.now(),
         compactDetail,
     };
-    contextState.schedulerLog = log;
+    state.schedulerLog = log;
     return log;
 }
 export { evaluateBudget, scheduleActions, formatReport };

package/dist/session/state.js

@@ -1,17 +1,21 @@
-// session/state.ts - 会话状态跟踪模块
-// 提供当前活跃会话 ID 的全局访问点，供 config/buildNotepadSection 等读取会话级 notes.md。
-// 避免 repl/index.ts ↔ config/index.ts 循环依赖。
-let currentSessionId;
-/** 获取当前活跃会话 ID(供 buildNotepadSection 等使用)。 */
+import { AsyncLocalStorage } from 'node:async_hooks';
+// Default-runtime session identity stays free of config/store imports to avoid initialization cycles.
+let defaultCurrentSessionId;
+const activeSessionIdProviders = new AsyncLocalStorage();
+/** 获取当前异步 runtime 的会话 ID；无 scope 时读取默认进程 runtime。 */
 export function getCurrentSessionId() {
-    return currentSessionId;
+    return activeSessionIdProviders.getStore()?.() ?? defaultCurrentSessionId;
 }
-/**
- * 设置当前活跃会话 ID。notes.md 由 agent 按需创建；这里不能预建空文件，
- * 否则 write_file(expected_hash=null) 的首次创建会必然冲突。
- * 由 repl/index.ts 在会话启动 / /resume 切换时调用。
- */
+/** SessionStore 默认兼容实例专用：绕过异步 scope，避免 provider 自递归。 */
+export function getDefaultCurrentSessionId() {
+    return defaultCurrentSessionId;
+}
+/** 设置默认进程 runtime 的当前活跃会话 ID。 */
 export function setCurrentSessionId(id, cwd) {
-    currentSessionId = id;
+    defaultCurrentSessionId = id;
     void cwd;
 }
+/** 让 notes/config 等旧读取入口在异步 runtime 树内看到实例会话身份。 */
+export function withCurrentSessionIdProvider(provider, run) {
+    return activeSessionIdProviders.run(provider, run);
+}

package/dist/session/store.js

@@ -0,0 +1,218 @@
+import { randomUUID } from 'node:crypto';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { config, getActiveModel } from '../config/index.js';
+import { isToolRouteGroupName } from '../config/profiles.js';
+import { truncateDisplay } from '../ui/render.js';
+import { getDefaultCurrentSessionId, setCurrentSessionId as setDefaultCurrentSessionId, withCurrentSessionIdProvider, } from './state.js';
+/** 新会话 id: 时间前缀保持可排序，毫秒与随机段避免同进程/跨进程碰撞。 */
+function createTimestampId() {
+    const d = new Date();
+    const p = (n, width = 2) => String(n).padStart(width, '0');
+    return `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}-${p(d.getMilliseconds(), 3)}-${randomUUID().slice(0, 8)}`;
+}
+/** 时间前缀 → ISO 字符串；兼容旧秒级 ID，解析失败回退原 id。 */
+function idToIso(id) {
+    const m = /^(\d{4})(\d{2})(\d{2})-(\d{2})(\d{2})(\d{2})(?:-(\d{3})-[a-f0-9]{8})?$/.exec(id);
+    if (!m)
+        return id;
+    return `${m[1]}-${m[2]}-${m[3]}T${m[4]}:${m[5]}:${m[6]}${m[7] ? `.${m[7]}` : ''}`;
+}
+function toText(content) {
+    if (content == null)
+        return '';
+    if (typeof content === 'string')
+        return content;
+    try {
+        return JSON.stringify(content);
+    }
+    catch {
+        return String(content);
+    }
+}
+function firstUserOf(history) {
+    for (const message of history) {
+        if (message.role !== 'user')
+            continue;
+        const text = toText(message.content)
+            .replace(/\n/g, ' ')
+            .trim();
+        return truncateDisplay(text, 40);
+    }
+    return '';
+}
+/**
+ * Runtime-local session persistence and identity.
+ *
+ * Disk format remains compatible with the historical helpers: the current format is
+ * `<sessionsRoot>/<id>/session.json`, with `<sessionsRoot>/<id>.json` as a read fallback.
+ */
+export class SessionStore {
+    workspaceRoot;
+    sessionsRootProvider;
+    getModel;
+    currentSessionIdProvider;
+    currentSessionIdSetter;
+    currentSessionId;
+    constructor(options = {}) {
+        this.workspaceRoot = path.resolve(options.workspaceRoot ?? process.cwd());
+        if (typeof options.sessionsRoot === 'function') {
+            const provider = options.sessionsRoot;
+            this.sessionsRootProvider = () => path.resolve(provider());
+        }
+        else {
+            const fixedRoot = path.resolve(options.sessionsRoot ?? config.sessionDir);
+            this.sessionsRootProvider = () => fixedRoot;
+        }
+        this.getModel = options.getModel ?? getActiveModel;
+        this.currentSessionIdProvider = options.getCurrentSessionId;
+        this.currentSessionIdSetter = options.setCurrentSessionId;
+    }
+    get sessionsRoot() {
+        return this.sessionsRootProvider();
+    }
+    sessionDir() {
+        const root = this.sessionsRoot;
+        mkdirSync(root, { recursive: true });
+        return root;
+    }
+    createId() {
+        return createTimestampId();
+    }
+    getCurrentSessionId() {
+        return this.currentSessionIdProvider?.() ?? this.currentSessionId;
+    }
+    setCurrentSessionId(id) {
+        if (this.currentSessionIdSetter)
+            this.currentSessionIdSetter(id);
+        else
+            this.currentSessionId = id;
+    }
+    sessionPath(id) {
+        return path.join(this.sessionsRoot, id, 'session.json');
+    }
+    artifactPath(id, filename) {
+        return path.join(this.sessionsRoot, id, filename);
+    }
+    appendTrace(id, value) {
+        try {
+            const dir = path.join(this.sessionsRoot, id);
+            mkdirSync(dir, { recursive: true });
+            const line = `${JSON.stringify(value)}\n`;
+            const tracePath = path.join(dir, 'trace.jsonl');
+            writeFileSync(tracePath, line, { encoding: 'utf8', flag: 'a' });
+        }
+        catch {
+            // Observability is best-effort and cannot block coding work.
+        }
+    }
+    save(history, id, queryHistory = [], lastToolGroups = []) {
+        const meta = {
+            id,
+            createdAt: idToIso(id),
+            model: this.getModel(),
+            firstUser: history.length > 1
+                ? firstUserOf(history)
+                : truncateDisplay((queryHistory[0] ?? '').replace(/\n/g, ' ').trim(), 40),
+        };
+        const currentPath = this.sessionPath(id);
+        const legacyPath = path.join(this.sessionsRoot, `${id}.json`);
+        if (history.length <= 1 && queryHistory.length === 0 && !existsSync(currentPath) && !existsSync(legacyPath)) {
+            return meta;
+        }
+        mkdirSync(path.join(this.sessionsRoot, id), { recursive: true });
+        const record = {
+            ...meta,
+            history,
+            queryHistory: [...queryHistory],
+            lastToolGroups: [...lastToolGroups],
+        };
+        writeFileSync(currentPath, JSON.stringify(record), 'utf8');
+        if (existsSync(legacyPath))
+            unlinkSync(legacyPath);
+        return meta;
+    }
+    load(id) {
+        const currentPath = this.sessionPath(id);
+        const legacyPath = path.join(this.sessionsRoot, `${id}.json`);
+        const source = existsSync(currentPath) ? currentPath : legacyPath;
+        if (!existsSync(source))
+            return null;
+        try {
+            const rec = JSON.parse(readFileSync(source, 'utf8'));
+            if (!rec || !Array.isArray(rec.history))
+                return null;
+            return {
+                id: rec.id,
+                createdAt: rec.createdAt ?? idToIso(rec.id ?? id),
+                model: rec.model ?? '',
+                firstUser: rec.firstUser ?? '',
+                history: rec.history,
+                queryHistory: Array.isArray(rec.queryHistory)
+                    ? rec.queryHistory.filter((query) => typeof query === 'string')
+                    : undefined,
+                lastToolGroups: Array.isArray(rec.lastToolGroups) ? rec.lastToolGroups.filter(isToolRouteGroupName) : undefined,
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    list(limit) {
+        const root = this.sessionsRoot;
+        if (!existsSync(root))
+            return [];
+        const entries = readdirSync(root, { withFileTypes: true });
+        const ids = [];
+        for (const entry of entries) {
+            if (entry.isDirectory() && /^\d{8}-\d{6}(?:-\d{3}-[a-f0-9]{8})?$/.test(entry.name)) {
+                ids.push(entry.name);
+            }
+            else if (entry.isFile() && entry.name.endsWith('.json') && !entry.name.endsWith('.snapshots.json')) {
+                ids.push(entry.name.replace(/\.json$/, ''));
+            }
+        }
+        const maxResults = typeof limit === 'number' ? Math.max(0, limit) : Infinity;
+        const out = [];
+        for (const id of ids.sort().reverse()) {
+            if (out.length >= maxResults)
+                break;
+            const currentPath = this.sessionPath(id);
+            const legacyPath = path.join(root, `${id}.json`);
+            const source = existsSync(currentPath) ? currentPath : legacyPath;
+            try {
+                const rec = JSON.parse(readFileSync(source, 'utf8'));
+                if (!rec || typeof rec.id !== 'string')
+                    continue;
+                out.push({
+                    id: rec.id,
+                    createdAt: rec.createdAt ?? idToIso(rec.id),
+                    model: rec.model ?? '',
+                    firstUser: rec.firstUser ?? '',
+                });
+            }
+            catch {
+                // 跳过损坏文件。
+            }
+        }
+        return out;
+    }
+}
+/** 旧函数 API 的进程级兼容实例；session root 每次读取 config，保留测试和运行时切换语义。 */
+export const defaultSessionStore = new SessionStore({
+    sessionsRoot: () => config.sessionDir,
+    workspaceRoot: process.cwd(),
+    getModel: getActiveModel,
+    getCurrentSessionId: getDefaultCurrentSessionId,
+    setCurrentSessionId: (id) => setDefaultCurrentSessionId(id, process.cwd()),
+});
+const activeSessionStores = new AsyncLocalStorage();
+/** 当前异步 runtime 树使用的 session store；无 scope 时回退默认兼容实例。 */
+export function getActiveSessionStore() {
+    return activeSessionStores.getStore() ?? defaultSessionStore;
+}
+/** 让旧 session/trace 入口在异步 runtime 树内自动使用对应实例。 */
+export function withSessionStore(store, run) {
+    return activeSessionStores.run(store, () => withCurrentSessionIdProvider(() => store.getCurrentSessionId(), run));
+}

package/dist/session/trace.js

@@ -1,9 +1,6 @@
 import { randomUUID } from 'node:crypto';
-import { appendFileSync, mkdirSync } from 'node:fs';
-import path from 'node:path';
-import { config } from '../config/index.js';
 import { getCurrentTurnId } from '../rollback/index.js';
-import { getCurrentSessionId } from './state.js';
+import { getActiveSessionStore } from './store.js';
 export function createTraceEvent(input) {
     return {
         schemaVersion: 1,
@@ -13,32 +10,25 @@ export function createTraceEvent(input) {
     };
 }
 function appendTraceLine(sessionId, value) {
-    try {
-        const dir = path.join(config.sessionDir, sessionId);
-        mkdirSync(dir, { recursive: true });
-        appendFileSync(path.join(dir, 'trace.jsonl'), `${JSON.stringify(value)}\n`, 'utf8');
-    }
-    catch {
-        // Observability is best-effort and cannot block coding work.
-    }
+    getActiveSessionStore().appendTrace(sessionId, value);
 }
 /** Persists a typed event in the current session's append-only black-box log. */
 export function appendCurrentSessionTraceEvent(event) {
-    const sessionId = getCurrentSessionId();
+    const sessionId = getActiveSessionStore().getCurrentSessionId();
     if (!sessionId)
         return;
     appendTraceLine(sessionId, { ...event, sessionId });
 }
 /** Records events initiated outside runAgentCore, such as Ctrl+C, /compact, and /rollback. */
 export function appendCurrentSessionRuntimeEvent(type, data, turnId = getCurrentTurnId()) {
-    const sessionId = getCurrentSessionId();
+    const sessionId = getActiveSessionStore().getCurrentSessionId();
     if (!sessionId)
         return;
     appendTraceLine(sessionId, createTraceEvent({ sessionId, turnId, type, data }));
 }
 /** Legacy turn-summary sink retained for API compatibility. New production code writes events. */
 export function appendCurrentSessionTrace(trace) {
-    const sessionId = getCurrentSessionId();
+    const sessionId = getActiveSessionStore().getCurrentSessionId();
     if (!sessionId)
         return;
     appendTraceLine(sessionId, { ...trace, sessionId });

package/dist/tools/policy.js

@@ -5,16 +5,16 @@ const clampConfidence = (value) => (Number.isFinite(value) ? Math.max(0, Math.mi
 function envGateAllows(name) {
     return !name || process.env[name] !== 'false';
 }
-function registeredNames() {
-    return tools.map((tool) => tool.name);
+function registeredNames(catalog = tools) {
+    return catalog.map((tool) => tool.name);
 }
-/** 当前进程真正可路由的簇；旧 env=false 只作为硬 veto，不再强制把簇常驻 schema。 */
-export function getAvailableToolRouteGroups() {
-    const names = registeredNames();
+/** 当前 runtime 真正可路由的簇；旧 env=false 只作为硬 veto，不再强制把簇常驻 schema。 */
+export function getAvailableToolRouteGroups(catalog = tools, gateAllows = envGateAllows) {
+    const names = registeredNames(catalog);
     const registered = new Set(names);
     return TOOL_ROUTE_GROUP_NAMES.filter((group) => {
         const definition = TOOL_ROUTE_GROUPS[group];
-        if (!envGateAllows(definition.gateEnv))
+        if (!gateAllows(definition.gateEnv))
             return false;
         const groupNames = getToolRouteGroupNames(group, names);
         if (group === 'mcp')
@@ -22,8 +22,8 @@ export function getAvailableToolRouteGroups() {
         return groupNames.length > 0 && groupNames.every((name) => registered.has(name));
     });
 }
-export function toolRouteCatalog(groups = getAvailableToolRouteGroups()) {
-    const names = registeredNames();
+export function toolRouteCatalog(groups = getAvailableToolRouteGroups(), catalog = tools) {
+    const names = registeredNames(catalog);
     return groups
         .map((group) => {
         const members = getToolRouteGroupNames(group, names);
@@ -31,8 +31,8 @@ export function toolRouteCatalog(groups = getAvailableToolRouteGroups()) {
     })
         .join('\n');
 }
-export function getToolChatSchema(name) {
-    const tool = tools.find((candidate) => candidate.name === name);
+export function getToolChatSchema(name, catalog = tools) {
+    const tool = catalog.find((candidate) => candidate.name === name);
     if (!tool)
         return null;
     return {
@@ -87,12 +87,16 @@ export class ToolPolicyController {
     confidence;
     autoCache = null;
     planCache = null;
+    catalog;
+    gateAllows;
     constructor(init = {}) {
+        this.catalog = init.tools ?? tools;
+        this.gateAllows = init.gateAllows ?? envGateAllows;
         this.id = init.id ?? `route-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
         this.maxExpansions = Math.max(0, init.maxExpansions ?? 3);
         this.reason = init.reason?.trim() || 'LLM router selected common tools only.';
         this.confidence = clampConfidence(init.confidence ?? 0);
-        const available = new Set(getAvailableToolRouteGroups());
+        const available = new Set(getAvailableToolRouteGroups(this.catalog, this.gateAllows));
         const requested = process.env.MOCODE_TOOL_POLICY === 'full' ? available : new Set(init.groups ?? []);
         for (const group of requested) {
             if (available.has(group))
@@ -106,7 +110,7 @@ export class ToolPolicyController {
         return this.expansionCount < this.maxExpansions && this.remainingGroups().length > 0;
     }
     remainingGroups() {
-        const available = new Set(getAvailableToolRouteGroups());
+        const available = new Set(getAvailableToolRouteGroups(this.catalog, this.gateAllows));
         return TOOL_ROUTE_GROUP_NAMES.filter((group) => available.has(group) && !this.selected.has(group));
     }
     snapshot(planMode = false) {
@@ -126,7 +130,7 @@ export class ToolPolicyController {
         const remaining = this.canExpand ? this.remainingGroups() : [];
         if (remaining.length > 0)
             append(ADD_TOOL_GROUPS_TOOL_NAME);
-        const registered = registeredNames();
+        const registered = registeredNames(this.catalog);
         for (const group of TOOL_ROUTE_GROUP_NAMES) {
             if (!this.selected.has(group))
                 continue;
@@ -139,7 +143,7 @@ export class ToolPolicyController {
         const chatTools = visibleNames.flatMap((name) => {
             if (name === ADD_TOOL_GROUPS_TOOL_NAME)
                 return [addToolGroupsSchema(remaining)];
-            const schema = getToolChatSchema(name);
+            const schema = getToolChatSchema(name, this.catalog);
             return schema ? [schema] : [];
         });
         const snapshot = {
@@ -168,7 +172,7 @@ export class ToolPolicyController {
                 snapshot: this.snapshot(false),
             };
         }
-        const available = new Set(getAvailableToolRouteGroups());
+        const available = new Set(getAvailableToolRouteGroups(this.catalog, this.gateAllows));
         for (const value of rawGroups) {
             if (!isToolRouteGroupName(value)) {
                 rejected.push(`${String(value)}: unknown group`);