opencode-metrics-plugin 0.1.5 → 0.2.0

package/dist/metrics/dirs.d.ts

@@ -0,0 +1,23 @@
+/** metrics/events 写入目录集。host 可自定义；默认按应用名 env paths。 */
+export interface MetricsDirs {
+    /** 会话快照 JSON 目录（<sessionId>.json 直接落这里；多引擎必须隔离，避免多写者冲突） */
+    metricsDir: string;
+    /** events 逐会话日志目录（steps 全文的数据源） */
+    eventsDir: string;
+    /** 运行日志文件（可选；logger 无文件权限时回退 console） */
+    logFile: string;
+}
+export declare function defaultDirs(appName?: string): MetricsDirs;
+/**
+ * 供 host 设定进程级默认目录（未显式传 dirs 的引擎/事件记录器使用）。
+ * 多引擎场景请优先在 createMetricsEngine/createEventLogger 实例级传 dirs，
+ * 进程级配置仅作默认兜底，避免多宿主互相覆盖。
+ */
+export declare function configureDirs(dirs: Partial<MetricsDirs>): void;
+/** 当前进程级默认目录（defaultDirs 与 configureDirs 的合并结果）。 */
+export declare function getDirs(): MetricsDirs;
+/** 解析实例目录：defaultDirs → 进程级默认（configureDirs）→ 实例传入，三层合并。 */
+export declare function resolveDirs(partial?: Partial<MetricsDirs>): MetricsDirs;
+export declare function getMetricsDir(): string;
+export declare function getEventsDir(): string;
+export declare function getLogFile(): string;

package/dist/{dirs.js → metrics/dirs.js}

@@ -1,32 +1,29 @@
 import envPaths from 'env-paths';
 import path from 'path';
+import { setLogFile } from '../shared/log.js';
 export function defaultDirs(appName = 'opencode-metrics-plugin') {
     const base = envPaths(appName, { suffix: '' });
     return {
         metricsDir: path.join(base.log, 'metrics'),
         eventsDir: path.join(base.log, 'events'),
         logFile: path.join(base.log, 'plugin.log'),
-        summaryFile: path.join(base.log, 'summary.db'),
     };
 }
 let _dirs = defaultDirs();
 /**
  * 供 host 设定进程级默认目录（未显式传 dirs 的引擎/事件记录器使用）。
- * 注意：多引擎场景请优先在 createMetricsEngine/createEventLogger 实例级传 dirs，
+ * 多引擎场景请优先在 createMetricsEngine/createEventLogger 实例级传 dirs，
  * 进程级配置仅作默认兜底，避免多宿主互相覆盖。
- * summaryFile 未显式配置时保持包级全局路径（跨宿主聚合语义）。
  */
 export function configureDirs(dirs) {
     _dirs = { ...defaultDirs(), ...dirs };
+    setLogFile(_dirs.logFile);
 }
 /** 当前进程级默认目录（defaultDirs 与 configureDirs 的合并结果）。 */
 export function getDirs() {
     return _dirs;
 }
-/**
- * 解析实例目录：defaultDirs → 进程级默认（configureDirs）→ 实例传入，三层合并。
- * summaryFile 不随 metricsDir 派生：缺省恒为全局共享库（实例/进程级显式指定才能改写）。
- */
+/** 解析实例目录：defaultDirs → 进程级默认（configureDirs）→ 实例传入，三层合并。 */
 export function resolveDirs(partial) {
     return partial ? { ...getDirs(), ...partial } : { ...getDirs() };
 }
@@ -39,6 +36,3 @@ export function getEventsDir() {
 export function getLogFile() {
     return _dirs.logFile;
 }
-export function getSummaryFile() {
-    return _dirs.summaryFile;
-}

package/dist/metrics/engine/engine.d.ts

@@ -0,0 +1,15 @@
+import type { MetricsEngine, MetricsOutput } from "../types.js";
+import type { MetricsDirs } from "../dirs.js";
+export type { TokenUsage, ToolStats, StageType, StageInfo, MessageEntry, ToolCallEntry, SessionMeta, CompileStats, SkillCallEntry, SkillSearchEntry, StepData, RoundSnapshot, SubAgentOutput, MetricsOutput, MetricsEngine, } from "../types.js";
+export interface MetricsEngineOptions {
+    enabled?: boolean;
+    /** 本引擎输出目录（多引擎各自独立）；缺省回退进程级默认（configureDirs），构造时解析固化 */
+    dirs?: Partial<MetricsDirs>;
+    /** flush 会话快照后回调（宿主可在此把快照上报自有系统） */
+    onFlush?: (sessionId: string, snapshot: MetricsOutput) => void;
+}
+/**
+ * 创建指标引擎：订阅事件流，按会话累计状态，idle/flush/dispose 产出快照 JSON。
+ * 0.2.0 起移除 scope 门控——记录全部会话；子会话（parentID）自动并入父会话。
+ */
+export declare function createMetricsEngine(opts?: MetricsEngineOptions): MetricsEngine;

package/dist/{metrics-engine.js → metrics/engine/engine.js}

@@ -1,93 +1,23 @@
-import { createSessionMetrics, TRACKED_EVENT_TYPES } from "./metrics-types.js";
-import { handlePartUpdated, handleSessionUpdated, handleMessageUpdated, handleSubAgentParts } from "./metrics-handlers.js";
-import { handleSessionIdle, flushMetrics, mergeChildMetrics } from "./metrics-output.js";
-import { resolveDirs } from "./dirs.js";
-import { log } from "./logger.js";
+import { TRACKED_EVENT_TYPES } from "../types.js";
+import { createSessionMetrics } from "./state.js";
+import { handlePartUpdated, handleSessionUpdated, handleMessageUpdated, handleSubAgentParts } from "./handlers.js";
+import { handleSessionIdle, flushMetrics } from "../snapshot/flush.js";
+import { mergeChildMetrics } from "../snapshot/merge.js";
+import { resolveDirs } from "../dirs.js";
+import { log } from "../../shared/log.js";
 /**
- * 创建指标引擎。
- * 兼容旧布尔入参：true = scope all，false = scope none。
- * 统计范围 = 策略 + 宿主声明（claimSession）的交集判定：
- *   - mode all     —— 全部（配合 agents 即只统计白名单 agent）
- *   - mode none    —— 默认不统计；宿主 claimSession 才统计
- *   - mode declared—— 仅宿主 claimSession 的会话（或 agents 白名单命中）
- *   - mode cwd     —— 仅工作目录命中 cwdPrefixes
- * 子会话（parentID 归属已统计父会话）自动随父会话统计。
+ * 创建指标引擎：订阅事件流，按会话累计状态，idle/flush/dispose 产出快照 JSON。
+ * 0.2.0 起移除 scope 门控——记录全部会话；子会话（parentID）自动并入父会话。
  */
-export function createMetricsEngine(opts = { enabled: true, scope: { mode: "all" } }) {
-    const options = typeof opts === "boolean"
-        ? { enabled: opts, scope: { mode: opts ? "all" : "none" } }
-        : opts;
-    const enabled = options.enabled !== false;
-    const scope = options.scope ?? { mode: "all" };
-    // 实例目录：构造时按 defaultDirs → 进程级默认 → 实例传入 三层合并固化；未传则 flush 时动态回退进程级默认
-    const instanceDirs = options.dirs ? resolveDirs(options.dirs) : undefined;
-    const agents = scope.agents && scope.agents.length > 0 ? new Set(scope.agents) : null;
-    const cwdPrefixes = scope.cwdPrefixes ?? [];
+export function createMetricsEngine(opts = {}) {
+    const enabled = opts.enabled !== false;
+    const instanceDirs = opts.dirs ? resolveDirs(opts.dirs) : undefined;
     const sessions = new Map();
     const childToParent = new Map();
     const childSessionIds = new Set();
-    const claimed = new Set();
-    // 已定案的会话统计与否（false 不缓存“信息未齐”的暂定，等 session.created 带 agent/dir 再定）
-    const resolved = new Map();
-    // 工作目录缓存（session.created 记录；cwd 策略与删除时反查用）
-    const sessionDirs = new Map();
-    const sessionAgents = new Map();
-    function decideFresh(id, agent, directory) {
-        if (claimed.has(id))
-            return true;
-        if (agents) {
-            if (!agent || !agents.has(agent))
-                return false;
-        }
-        switch (scope.mode) {
-            case "all": return true;
-            case "none": return false;
-            case "declared": return false;
-            case "cwd": return directory != null && cwdPrefixes.some((p) => directory.startsWith(p));
-            default: return false;
-        }
-    }
-    /** 需等待 agent/directory 才可定案（事件带信息前先跳过，session.created 到达后定案）。 */
-    function needsInfo(id, agent, directory) {
-        if (agents && !agent)
-            return true;
-        if (scope.mode === "cwd" && directory == null)
-            return true;
-        return false;
-    }
     function resolveSessionId(rawId) {
         return childToParent.get(rawId) ?? rawId;
     }
-    /** 判断事件目标会话是否纳入统计（子会话跟随父会话定案）。 */
-    function isTracked(id, eventType, props) {
-        let target = id;
-        if (id.startsWith("__migrate__:")) {
-            target = id.split(":")[2] ?? "";
-        }
-        else {
-            target = childToParent.get(id) ?? id;
-        }
-        if (!target)
-            return false;
-        const info = (props?.info ?? {});
-        const agent = typeof info.agent === "string" ? info.agent : sessionAgents.get(target);
-        const directory = typeof info.directory === "string" ? info.directory : sessionDirs.get(target);
-        // 记录目录/agent（含迁移解析出的父子关系场景）
-        if (eventType === "session.created" || eventType === "session.updated") {
-            if (typeof info.directory === "string")
-                sessionDirs.set(target, info.directory);
-            if (typeof info.agent === "string")
-                sessionAgents.set(target, info.agent);
-        }
-        const cached = resolved.get(target);
-        if (cached !== undefined)
-            return cached;
-        if (needsInfo(target, agent, directory))
-            return false;
-        const decision = decideFresh(target, agent, directory);
-        resolved.set(target, decision);
-        return decision;
-    }
     function extractSessionId(event) {
         const props = event.properties;
         if (!props) {
@@ -104,7 +34,7 @@ export function createMetricsEngine(opts = { enabled: true, scope: { mode: "all"
                     childSessionIds.add(id);
                     const agentName = info.agent || "";
                     const title = info.title || "";
-                    log.info("[Metrics] MIGRATE detected", { type: event.type, id, parentID, agentName, title });
+                    log.info("[Metrics] sub-agent detected", { type: event.type, id, parentID, agentName, title });
                     return `__migrate__:${id}:${parentID}:${agentName}:${title}`;
                 }
                 if (id)
@@ -117,7 +47,7 @@ export function createMetricsEngine(opts = { enabled: true, scope: { mode: "all"
         const info = props.info;
         if (info?.id)
             return resolveSessionId(info.id);
-        log.info("[Metrics] extractSessionId: no sessionID found", { type: event.type, hasSessionID: !!props.sessionID, hasInfo: !!info, hasInfoId: !!info?.id });
+        log.info("[Metrics] extractSessionId: no sessionID found", { type: event.type });
         return undefined;
     }
     function getOrCreateSession(sessionId) {
@@ -128,6 +58,16 @@ export function createMetricsEngine(opts = { enabled: true, scope: { mode: "all"
         }
         return state;
     }
+    function emitFlush(sessionId, snapshot) {
+        if (snapshot && opts.onFlush) {
+            try {
+                opts.onFlush(sessionId, snapshot);
+            }
+            catch (err) {
+                log.error("[Metrics] onFlush failed", { sessionId, error: String(err) });
+            }
+        }
+    }
     return {
         ingest(event) {
             if (!enabled)
@@ -140,10 +80,7 @@ export function createMetricsEngine(opts = { enabled: true, scope: { mode: "all"
                 return;
             }
             const props = event.properties;
-            // 统计范围门：未纳入范围的会话整条丢弃（含其子代理）
-            if (!isTracked(sessionId, event.type, props))
-                return;
-            // Handle buffer migration when sub-agent relationship is discovered
+            // 子代理关系发现时迁移既有缓冲状态
             if (sessionId.startsWith("__migrate__:")) {
                 const parts = sessionId.split(":");
                 const childId = parts[1];
@@ -152,7 +89,6 @@ export function createMetricsEngine(opts = { enabled: true, scope: { mode: "all"
                 const title = parts[4] || "";
                 sessionId = parentId;
                 const parentState = getOrCreateSession(parentId);
-                // Merge child's existing metrics to parent
                 const childState = sessions.get(childId);
                 if (childState) {
                     log.info("[Metrics] Migration: merging existing child state", { childId, parentId });
@@ -179,7 +115,7 @@ export function createMetricsEngine(opts = { enabled: true, scope: { mode: "all"
                 }
             }
             const state = getOrCreateSession(sessionId);
-            // Sub-agent routing: check if the original event was from a child session
+            // 子代理事件路由：原始事件来自子会话时进入对应 subAgents 条目
             const originalSessionId = props?.sessionID || "";
             if (childSessionIds.has(originalSessionId)) {
                 const sub = state.subAgents.get(originalSessionId);
@@ -191,21 +127,18 @@ export function createMetricsEngine(opts = { enabled: true, scope: { mode: "all"
                     log.info("[Metrics] Sub-agent routing MISS — entry not found", { eventType: event.type, originalSessionId, subAgentsKeys: [...state.subAgents.keys()] });
                 }
             }
-            // Extract directory from session.created
+            // 提取工作目录
             if (event.type === "session.created" && props) {
                 const info = props.info;
                 const directory = info?.directory;
-                if (directory) {
+                if (directory)
                     state.sessionMeta.workingDirectory = directory;
-                    sessionDirs.set(sessionId, directory);
-                }
             }
-            // Track per-round first event time
+            // 轮内首个事件时间
             if (!state._hasFirstEvent) {
                 state._hasFirstEvent = true;
                 state._firstEventTime = Date.now();
             }
-            // Route to handler by event type
             if (event.type === "message.part.updated" && props) {
                 handlePartUpdated(state, props);
             }
@@ -213,15 +146,7 @@ export function createMetricsEngine(opts = { enabled: true, scope: { mode: "all"
                 handleSessionUpdated(state, props);
             }
             if (event.type === "session.idle") {
-                const snapshot = handleSessionIdle(state, sessionId, instanceDirs);
-                if (options.onFlush && snapshot) {
-                    try {
-                        options.onFlush(sessionId, snapshot);
-                    }
-                    catch (err) {
-                        log.error("[Metrics] onFlush failed", { sessionId, error: String(err) });
-                    }
-                }
+                emitFlush(sessionId, handleSessionIdle(state, sessionId, instanceDirs));
             }
             if (event.type === "session.compacted") {
                 state.compactions++;
@@ -244,13 +169,7 @@ export function createMetricsEngine(opts = { enabled: true, scope: { mode: "all"
         ingestPrompt(sessionId, modelId, system) {
             if (!enabled)
                 return;
-            const resolvedId = resolveSessionId(sessionId);
-            const allowed = (scope.mode === "all" && !agents) ||
-                claimed.has(resolvedId) ||
-                resolved.get(resolvedId) === true;
-            if (!allowed)
-                return;
-            const state = getOrCreateSession(resolvedId);
+            const state = getOrCreateSession(resolveSessionId(sessionId));
             state.systemPrompts.set(modelId, system);
         },
         isSubAgent(sessionId) {
@@ -262,15 +181,7 @@ export function createMetricsEngine(opts = { enabled: true, scope: { mode: "all"
                 return;
             const now = Date.now();
             state.endTime = now;
-            const snapshot = flushMetrics(sessionId, state, now, instanceDirs);
-            if (options.onFlush && snapshot) {
-                try {
-                    options.onFlush(sessionId, snapshot);
-                }
-                catch (err) {
-                    log.error("[Metrics] onFlush failed", { sessionId, error: String(err) });
-                }
-            }
+            emitFlush(sessionId, flushMetrics(sessionId, state, now, instanceDirs));
         },
         dispose() {
             const now = Date.now();
@@ -297,35 +208,11 @@ export function createMetricsEngine(opts = { enabled: true, scope: { mode: "all"
                     state.compileStats._pendingFix = null;
                 }
                 state.endTime = now;
-                const snapshot = flushMetrics(sessionId, state, now, instanceDirs);
-                if (options.onFlush && snapshot) {
-                    try {
-                        options.onFlush(sessionId, snapshot);
-                    }
-                    catch (err) {
-                        log.error("[Metrics] onFlush failed", { sessionId, error: String(err) });
-                    }
-                }
+                emitFlush(sessionId, flushMetrics(sessionId, state, now, instanceDirs));
             }
             sessions.clear();
             childToParent.clear();
             childSessionIds.clear();
         },
-        claimSession(sessionId, meta) {
-            claimed.add(sessionId);
-            if (meta?.agent)
-                sessionAgents.set(sessionId, meta.agent);
-            // 允许 claim 推翻早前“信息未齐暂不统计”的判定；宿主显式声明即强制纳入
-            resolved.set(sessionId, true);
-        },
-        scopeOf(sessionId) {
-            const v = resolved.get(sessionId);
-            if (v !== undefined)
-                return v;
-            return claimed.has(sessionId);
-        },
-        shouldTrack(sessionId, eventType, props) {
-            return isTracked(sessionId, eventType, props);
-        },
     };
 }

package/dist/{metrics-handlers.d.ts → metrics/engine/handlers.d.ts}

@@ -1,4 +1,4 @@
-import type { SessionMetricsState, SubAgentState } from "./metrics-types.js";
+import type { SessionMetricsState, SubAgentState } from "./state.js";
 declare function handlePartUpdated(state: SessionMetricsState, props: Record<string, unknown>): void;
 declare function handleSessionUpdated(state: SessionMetricsState, props: Record<string, unknown>): void;
 declare function handleMessageUpdated(state: SessionMetricsState, props: Record<string, unknown>): void;

package/dist/{metrics-handlers.js → metrics/engine/handlers.js}

@@ -1,5 +1,5 @@
-import { createTokenUsage } from "./metrics-types.js";
-import { parseHvigorwOutput } from "./compile-analyzer.js";
+import { createTokenUsage } from "../types.js";
+import { parseHvigorwOutput } from "../analysis/hvigor.js";
 // ─── Input Simplification ────────────────────────────────────────────────────
 function simplifyInput(raw) {
     if (!raw)

package/dist/metrics/engine/state.d.ts

@@ -0,0 +1,79 @@
+import type { MessageEntry, PlanningCall, RoundSnapshot, SkillCallEntry, SkillSearchEntry, TokenUsage, ToolCallEntry, SessionMeta, CompileStats, StageInfo, ToolStats } from "../types.js";
+export interface SubAgentState {
+    sessionId: string;
+    agentName: string;
+    title: string;
+    messageMap: Map<string, MessageEntry>;
+    toolCallMap: Map<string, ToolCallEntry>;
+    textLengthMap: Map<string, number>;
+    orderCounter: number;
+    _userMessageIds: Set<string>;
+    _pendingUserMessage: string[];
+}
+export interface SessionMetricsState {
+    sessionId: string;
+    startTime: number;
+    endTime: number;
+    rounds: RoundSnapshot[];
+    tokens: TokenUsage;
+    tools: {
+        totalCalls: number;
+        invalidCalls: number;
+        completedCalls: number;
+        errorCalls: number;
+        distribution: Map<string, ToolStats>;
+        slowestCall: {
+            tool: string;
+            duration: number;
+        };
+    };
+    agent: {
+        current: string;
+        switches: number;
+        lastSwitchTime: number;
+        usage: Map<string, number>;
+    };
+    model: {
+        current: string;
+        switches: number;
+        tokenDistribution: Map<string, TokenUsage>;
+    };
+    compactions: number;
+    anomaly: {
+        triggered: boolean;
+        events: string[];
+    };
+    currentStage: StageInfo | null;
+    stages: StageInfo[];
+    lastStageEndTime: number;
+    _stageTokens: TokenUsage;
+    _roundStartTime: number;
+    _firstEventTime: number;
+    _firstTextTime: number;
+    _hasFirstEvent: boolean;
+    _hasTextPart: boolean;
+    _roundTokens: TokenUsage;
+    _roundToolCalls: number;
+    _roundErrors: number;
+    _roundFirstBuildTracked: boolean;
+    _roundIdleProcessed: boolean;
+    _idleFlushed: boolean;
+    messageMap: Map<string, MessageEntry>;
+    toolCallMap: Map<string, ToolCallEntry>;
+    textLengthMap: Map<string, number>;
+    sessionMeta: SessionMeta;
+    compileStats: CompileStats;
+    orderCounter: number;
+    skillCallMap: Map<string, SkillCallEntry>;
+    htmlPreviewMsgId: string | null;
+    skillSearchMap: Map<string, SkillSearchEntry>;
+    _pendingReadChain: {
+        searchCallID: string;
+    } | null;
+    _userMessageIds: Set<string>;
+    _pendingUserMessage: string[];
+    subAgents: Map<string, SubAgentState>;
+    planningCalls: PlanningCall[];
+    systemPrompts: Map<string, string[]>;
+}
+export declare function createSessionMetrics(sessionId: string): SessionMetricsState;

package/dist/{metrics-types.js → metrics/engine/state.js}

@@ -1,23 +1,5 @@
-export const TRACKED_EVENT_TYPES = new Set([
-    "session.created",
-    "session.updated",
-    "session.idle",
-    "session.deleted",
-    "session.compacted",
-    "session.status",
-    "session.error",
-    "message.updated",
-    "message.removed",
-    "message.part.updated",
-    "message.part.removed",
-    "permission.asked",
-    "permission.replied",
-    "command.executed",
-]);
+import { createTokenUsage } from "../types.js";
 // ─── Factory Functions ───────────────────────────────────────────────────────
-export function createTokenUsage() {
-    return { input: 0, output: 0, reasoning: 0, cacheRead: 0, cacheWrite: 0, total: 0 };
-}
 export function createSessionMetrics(sessionId) {
     const now = Date.now();
     return {

package/dist/{event-logger.d.ts → metrics/eventlog/event-logger.d.ts}

@@ -11,10 +11,5 @@ export interface EventLogger {
 export interface EventLoggerOptions {
     /** 本实例事件日志目录（多引擎场景各自独立）；缺省回退进程级默认（configureDirs） */
     eventsDir?: string;
-    /** 会话归属门控：返回 false 的事件不写入本实例日志（与引擎共用同一 scope 判定） */
-    isTracked?: (sessionId: string, event: {
-        type: string;
-        properties?: Record<string, unknown>;
-    }) => boolean;
 }
 export declare function createEventLogger(enabled: boolean, cleanupEnabled?: boolean, opts?: EventLoggerOptions): EventLogger;

package/dist/{event-logger.js → metrics/eventlog/event-logger.js}

@@ -1,7 +1,7 @@
 import * as fs from "fs";
 import * as path from "path";
-import { getEventsDir } from "./dirs.js";
-import { TRACKED_EVENT_TYPES } from "./metrics-types.js";
+import { getEventsDir } from "../dirs.js";
+import { TRACKED_EVENT_TYPES } from "../types.js";
 // Rotation constants
 const MAX_LOG_SIZE_BYTES = 20 * 1024 * 1024;
 const MAX_LOG_AGE_DAYS = 7;
@@ -9,7 +9,6 @@ const MAX_ROTATED_FILES = 5;
 const FLUSH_INTERVAL_MS = 500;
 const BUFFER_SIZE_LIMIT = 50;
 const SEPARATOR = "=".repeat(72);
-// 鈹€鈹€鈹€ Helpers 鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€
 function formatTimestamp(date) {
     const pad = (n) => String(n).padStart(2, "0");
     const ms = String(Math.floor(date.getMilliseconds() / 10)).padStart(2, "0");
@@ -239,18 +238,6 @@ export function createEventLogger(enabled, cleanupEnabled = false, opts = {}) {
             if (sessionId.startsWith("__migrate__:")) {
                 const [, childId, parentId] = sessionId.split(":");
                 sessionId = parentId;
-                // 子会话归属随父：父未纳入统计时丢弃子缓冲，不产生日志文件
-                if (opts.isTracked && !opts.isTracked(parentId, event)) {
-                    const dropBuf = sessionBuffers.get(childId);
-                    if (dropBuf) {
-                        if (dropBuf.flushTimer) {
-                            clearTimeout(dropBuf.flushTimer);
-                            dropBuf.flushTimer = null;
-                        }
-                        sessionBuffers.delete(childId);
-                    }
-                    return;
-                }
                 // Move child's existing buffer to parent
                 const childBuf = sessionBuffers.get(childId);
                 if (childBuf) {
@@ -273,9 +260,6 @@ export function createEventLogger(enabled, cleanupEnabled = false, opts = {}) {
                     subAgent = { childId: rawSessionId };
                 }
             }
-            // 归属门控：未纳入统计范围的会话不记录事件
-            if (opts.isTracked && !opts.isTracked(sessionId, event))
-                return;
             const buf = getOrCreateBuffer(sessionId);
             const ts = formatTimestamp(new Date());
             // Write formatted event block

package/dist/metrics/index.d.ts

@@ -0,0 +1,9 @@
+export { createMetricsEngine } from './engine/engine.js';
+export type { MetricsEngineOptions } from './engine/engine.js';
+export { configureDirs, defaultDirs, getDirs, resolveDirs, getMetricsDir, getEventsDir, getLogFile } from './dirs.js';
+export type { MetricsDirs } from './dirs.js';
+export { createEventLogger } from './eventlog/event-logger.js';
+export type { EventLogger, EventLoggerOptions } from './eventlog/event-logger.js';
+export { createMetricsRuntime } from './runtime.js';
+export type { MetricsRuntime, MetricsRuntimeOptions } from './runtime.js';
+export * from './types.js';

package/dist/metrics/index.js

@@ -0,0 +1,6 @@
+// metrics 域出口：会话指标采集（引擎/快照/事件日志/编译分析/目录管理/运行时组装）
+export { createMetricsEngine } from './engine/engine.js';
+export { configureDirs, defaultDirs, getDirs, resolveDirs, getMetricsDir, getEventsDir, getLogFile } from './dirs.js';
+export { createEventLogger } from './eventlog/event-logger.js';
+export { createMetricsRuntime } from './runtime.js';
+export * from './types.js';

package/dist/metrics/runtime.d.ts

@@ -0,0 +1,25 @@
+import type { MetricsEngineOptions } from './engine/engine.js';
+import type { MetricsDirs } from './dirs.js';
+export interface MetricsRuntimeOptions extends Omit<MetricsEngineOptions, 'enabled'> {
+    dirs?: Partial<MetricsDirs>;
+    enabled?: boolean;
+    /** 事件写盘（events/<sessionId>.log；steps 全文的数据源） */
+    eventLogging?: boolean;
+}
+/**
+ * 组装一整套"通用统计插件"的运行时：事件记录 + 指标引擎。
+ * 目录为实例级（不产生全局副作用）：defaultDirs → 进程级默认（configureDirs）→ opts.dirs 三层合并。
+ */
+export declare function createMetricsRuntime(opts?: MetricsRuntimeOptions): {
+    dirs: MetricsDirs;
+    eventLogger: import("./eventlog/event-logger.js").EventLogger | null;
+    engine: import("./types.js").MetricsEngine;
+    /** opencode event hook：`async ({ event }) => { runtime.event({ event }) }` */
+    event(input: {
+        event: {
+            type: string;
+            properties?: Record<string, unknown>;
+        };
+    }): void;
+};
+export type MetricsRuntime = ReturnType<typeof createMetricsRuntime>;

package/dist/metrics/runtime.js

@@ -0,0 +1,28 @@
+import { createMetricsEngine } from './engine/engine.js';
+import { createEventLogger } from './eventlog/event-logger.js';
+import { resolveDirs } from './dirs.js';
+/**
+ * 组装一整套"通用统计插件"的运行时：事件记录 + 指标引擎。
+ * 目录为实例级（不产生全局副作用）：defaultDirs → 进程级默认（configureDirs）→ opts.dirs 三层合并。
+ */
+export function createMetricsRuntime(opts = {}) {
+    const dirs = resolveDirs(opts.dirs);
+    const engine = createMetricsEngine({
+        enabled: opts.enabled,
+        dirs,
+        onFlush: opts.onFlush,
+    });
+    const eventLogger = (opts.eventLogging ?? true)
+        ? createEventLogger(true, false, { eventsDir: dirs.eventsDir })
+        : null;
+    return {
+        dirs,
+        eventLogger,
+        engine,
+        /** opencode event hook：`async ({ event }) => { runtime.event({ event }) }` */
+        event(input) {
+            eventLogger?.log(input.event);
+            engine.ingest(input.event);
+        },
+    };
+}

package/dist/metrics/snapshot/flush.d.ts

@@ -0,0 +1,6 @@
+import type { MetricsDirs } from "../dirs.js";
+import type { SessionMetricsState } from "../engine/state.js";
+import type { MetricsOutput } from "../types.js";
+declare function flushMetrics(sessionId: string, state: SessionMetricsState, now: number, dirs?: Partial<MetricsDirs>): MetricsOutput;
+declare function handleSessionIdle(state: SessionMetricsState, sessionId: string, dirs?: Partial<MetricsDirs>): MetricsOutput | undefined;
+export { flushMetrics, handleSessionIdle };