@capybara-hq/kernel 0.0.0-stage → 0.1.0-rc.1

package/dist/evals/trajectory.d.ts

@@ -0,0 +1,144 @@
+import type { ModelUsage } from "@capybara-hq/plugin-sdk";
+import type { ConversationEvent, EventPayload } from "../conversations/events.js";
+import { type PriceTable } from "../models/prices.js";
+/**
+ * 轨迹读模型（D6、C2）：由会话事件日志推出每次运行的步骤、模型调用与工具调用，纯函数、不读库。
+ * 延迟与耗时只由事件的 `created_at` 推出，不加事件字段；成本读时按价格表算，不写日志。
+ */
+/** 一次模型请求（一条 `model_call` 事件）。 */
+export interface TrajectoryModelCall {
+    seq: number;
+    step: number;
+    attempt: number;
+    provider: string;
+    model: string;
+    fallback: boolean;
+    startedAt: string;
+    /** 该步 `usage` 时间 − `model_call` 时间；失败 / 进行中为 null。 */
+    latencyMs: number | null;
+    /** 该步写了 usage 且本次是最后一次尝试 → ok；运行未结束且该步还没有回复 → pending；其余为 failed。 */
+    outcome: "ok" | "failed" | "pending";
+    usage: ModelUsage | null;
+    /** 估算成本（币种见响应的 `currency`）；没有用量或没有价格时为 null。 */
+    cost: number | null;
+    request: EventPayload<"model_call">["request"];
+}
+/** A plugin policy hook's denial (`hook_denied`): cause and sanitized reason (raw errors: audit log). */
+export interface TrajectoryHookDenial {
+    plugin: string;
+    reason: string;
+    cause: "deny" | "hook_error" | "timeout";
+}
+/** 一次工具调用（模型回复里的一个 `tool_call` 块）。 */
+export interface TrajectoryToolCall {
+    callId: string;
+    step: number;
+    toolKey: string;
+    /** 取自该步 `assistant_message` 里的 `tool_call` 块。 */
+    input: unknown;
+    /** 最后一次 `tool_call_started`（输入请求之后会再次执行）；从未开始执行（如审批被拒）为 null。 */
+    startedAt: string | null;
+    /** `tool_result` − 最后一次 `tool_call_started`；不含等待审批 / 用户输入的时间。 */
+    durationMs: number | null;
+    result: {
+        content: string;
+        isError: boolean;
+        outputId?: string;
+    } | null;
+    /** 最近一次审批（定义变了会重新审批）。 */
+    approval: {
+        approvalId: string;
+        requestedAt: string;
+        decision: "approved" | "denied" | "expired" | "cancelled" | null;
+        scope?: "once" | "session" | "always";
+        byAccountId: string | null;
+        decidedAt: string | null;
+    } | null;
+    /** 最近一次输入请求（`ask_user`、插件 `input_required`、MCP elicitation）。 */
+    question: {
+        questionId: string;
+        askedAt: string;
+        outcome: "answered" | "expired" | "cancelled" | null;
+        byAccountId: string | null;
+    } | null;
+    /** A `tool.preExecute` policy hook denied the call (it never started). */
+    hookDenied?: TrajectoryHookDenial;
+    /**
+     * An `agent` call that dispatched (or resumed) a sub-agent (phase C, spec §15.4): the child
+     * conversation (`subagentId`, whose trajectory the viewer links to), the run it started and that
+     * run's end (`running` until its `subagent_finished`).
+     */
+    subagent?: {
+        subagentId: string;
+        childRunId: string;
+        agentType: string;
+        resumed: boolean;
+        status: EventPayload<"subagent_finished">["status"] | "running";
+    };
+}
+export interface TrajectoryStep {
+    step: number;
+    /**
+     * A `model.request` policy hook denied the step's request (attempt number included). The denied
+     * attempt has no `model_call` (it was never sent), so the denial sits on the step, next to
+     * `modelCalls`.
+     */
+    modelHookDenied?: TrajectoryHookDenial & {
+        attempt?: number;
+    };
+    modelCalls: TrajectoryModelCall[];
+    toolCalls: TrajectoryToolCall[];
+    /** 该步模型回复里的文本块（不含 thinking）按顺序拼接；还没有回复时为空串。 */
+    text: string;
+    stopReason: string | null;
+}
+/**
+ * A run triggered by a person's fork invocation (phase D spec §6.3): the skill as typed, the
+ * sub-agent it dispatched (`callId` `skill-<seq>`, no tool call; absent when none ran) and the
+ * report logged for the parent (`skill_fork_result`, null until written).
+ */
+export interface TrajectorySkillFork {
+    invokedSeq: number;
+    skill: {
+        name: string;
+        plugin?: string;
+        arguments: string;
+    };
+    subagent?: {
+        subagentId: string;
+        childRunId: string;
+        agentType: string;
+        status: EventPayload<"subagent_finished">["status"] | "running";
+    };
+    report: string | null;
+}
+export interface TrajectoryRun {
+    runId: string;
+    agentVersion: number;
+    triggerAccountId: string;
+    startedAt: string;
+    endedAt: string | null;
+    /** `detail`：结束原因（finished / aborted 的 `reason`）或失败码（`error.code`）。 */
+    end: {
+        kind: "finished" | "failed" | "aborted";
+        detail: string;
+    } | null;
+    /** Phase D: the run's fork invocation (its trigger), when it has one. */
+    skillFork?: TrajectorySkillFork;
+    steps: TrajectoryStep[];
+    totals: {
+        /** Usage of the step calls plus the compaction calls (`usage` events with `purpose: "compaction"`). */
+        usage: ModelUsage;
+        /** 各次成功调用的成本之和（含压缩调用）；任一成功调用没有价格时为 null（部分求和会误导）。 */
+        cost: number | null;
+        modelCalls: number;
+        toolCalls: number;
+        /** `endedAt − startedAt`（含等待审批 / 输入的时间）；运行未结束为 null。 */
+        durationMs: number | null;
+    };
+}
+/**
+ * 由会话事件推出各次运行的轨迹，按 `run_started` 的 seq 排序。没有 `run_started` 的运行（排队时就被中止 /
+ * 判为孤儿，从未开始）不出现；没有 `runId` 的事件（用户消息等）不属于任何运行。
+ */
+export declare function buildTrajectory(events: readonly ConversationEvent[], prices: PriceTable): TrajectoryRun[];

package/dist/evals/trajectory.js

@@ -0,0 +1,338 @@
+import { costOf, priceKey } from "../models/prices.js";
+const iso = (d) => d.toISOString();
+const denialOf = (e) => ({
+    plugin: e.payload.plugin,
+    reason: e.payload.reason,
+    cause: e.payload.cause,
+});
+const ms = (from, to) => to.getTime() - from.getTime();
+const zeroUsage = () => ({
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0,
+});
+const usageOf = (p) => ({
+    inputTokens: p.inputTokens,
+    outputTokens: p.outputTokens,
+    cacheReadTokens: p.cacheReadTokens,
+    cacheWriteTokens: p.cacheWriteTokens,
+});
+/**
+ * 由会话事件推出各次运行的轨迹，按 `run_started` 的 seq 排序。没有 `run_started` 的运行（排队时就被中止 /
+ * 判为孤儿，从未开始）不出现；没有 `runId` 的事件（用户消息等）不属于任何运行。
+ */
+export function buildTrajectory(events, prices) {
+    const sorted = [...events].sort((a, b) => a.seq - b.seq);
+    const byRun = new Map();
+    for (const e of sorted) {
+        if (e.runId === null)
+            continue;
+        let list = byRun.get(e.runId);
+        if (!list) {
+            list = [];
+            byRun.set(e.runId, list);
+        }
+        list.push(e);
+    }
+    const runs = [];
+    for (const list of byRun.values()) {
+        const started = list.find((e) => e.type === "run_started");
+        if (started)
+            runs.push({ started, events: list });
+    }
+    runs.sort((a, b) => a.started.seq - b.started.seq);
+    // fork invocations (phase D) by seq: the message itself belongs to no run
+    const forks = new Map();
+    for (const e of sorted) {
+        if (e.type === "user_message" && e.payload.skill?.mode === "fork") {
+            forks.set(e.seq, e.payload.skill);
+        }
+    }
+    return runs.map((r) => buildRun(r, prices, forks));
+}
+/** The run's fork span (phase D): from its fork dispatch or its fork report. */
+function skillForkOf(events, forks) {
+    const dispatch = events.find((e) => e.type === "subagent_dispatched" && e.payload.invokedSeq !== undefined);
+    const report = events.find((e) => e.type === "skill_fork_result");
+    const seq = dispatch?.payload.invokedSeq ?? report?.payload.invokedSeq;
+    const skill = seq === undefined ? undefined : forks.get(seq);
+    if (seq === undefined || skill === undefined)
+        return undefined;
+    const d = dispatch?.payload;
+    const end = d === undefined
+        ? undefined
+        : events.find((e) => e.type === "subagent_finished" && e.payload.childRunId === d.childRunId);
+    return {
+        invokedSeq: seq,
+        skill: {
+            name: skill.name,
+            ...(skill.plugin !== undefined && { plugin: skill.plugin }),
+            arguments: skill.arguments,
+        },
+        ...(d !== undefined && {
+            subagent: {
+                subagentId: d.subagentId,
+                childRunId: d.childRunId,
+                agentType: d.agentType,
+                status: end?.payload.status ?? "running",
+            },
+        }),
+        report: report?.payload.text ?? null,
+    };
+}
+function buildRun({ started, events }, prices, forks) {
+    const runId = started.runId ?? "";
+    const endEvent = events.find((e) => e.type === "run_finished" || e.type === "run_failed" || e.type === "run_aborted");
+    const end = endEvent === undefined
+        ? null
+        : endEvent.type === "run_finished"
+            ? { kind: "finished", detail: endEvent.payload.reason }
+            : endEvent.type === "run_failed"
+                ? { kind: "failed", detail: endEvent.payload.error.code }
+                : // 评测回放被停下时给出具体原因（capped / too_many_errors / claim_lost / cancelled / shutdown）
+                    { kind: "aborted", detail: endEvent.payload.detail ?? endEvent.payload.reason };
+    const modelCalls = new Map();
+    const assistants = new Map();
+    const usages = new Map();
+    const compactions = [];
+    const toolStarts = new Map(); // callId → 最后一次
+    const toolResults = new Map();
+    const approvals = new Map(); // callId → 最近一次
+    const decisions = new Map(); // approvalId → 决定
+    const questions = new Map(); // callId → 最近一次
+    const answers = new Map(); // questionId → 结果
+    const toolDenials = new Map(); // callId → denial
+    const modelDenials = new Map(); // step → denial
+    const dispatches = new Map(); // callId → dispatch
+    const childEnds = new Map(); // childRunId → end
+    /** 步骤里出现过的调用 id（按首次出现），用于给不在 assistant_message 里的调用兜底。 */
+    const stepCalls = new Map();
+    const steps = new Set();
+    const noteCall = (step, callId) => {
+        steps.add(step);
+        const list = stepCalls.get(step) ?? [];
+        if (!list.includes(callId))
+            list.push(callId);
+        stepCalls.set(step, list);
+    };
+    for (const e of events) {
+        switch (e.type) {
+            case "model_call": {
+                steps.add(e.payload.step);
+                const list = modelCalls.get(e.payload.step) ?? [];
+                list.push(e);
+                modelCalls.set(e.payload.step, list);
+                break;
+            }
+            case "assistant_message":
+                steps.add(e.payload.step);
+                assistants.set(e.payload.step, [...(assistants.get(e.payload.step) ?? []), e]);
+                break;
+            case "usage":
+                // a compaction or title call's usage is not a step call's: counted in the totals only (I-1)
+                if (e.payload.purpose !== undefined) {
+                    compactions.push(e);
+                    break;
+                }
+                steps.add(e.payload.step);
+                usages.set(e.payload.step, [...(usages.get(e.payload.step) ?? []), e]);
+                break;
+            case "tool_call_started":
+                noteCall(e.payload.step, e.payload.callId);
+                toolStarts.set(e.payload.callId, e);
+                break;
+            case "tool_result":
+                noteCall(e.payload.step, e.payload.callId);
+                if (!toolResults.has(e.payload.callId))
+                    toolResults.set(e.payload.callId, e);
+                break;
+            case "approval_requested":
+                noteCall(e.payload.step, e.payload.callId);
+                approvals.set(e.payload.callId, e);
+                break;
+            case "approval_decided":
+                decisions.set(e.payload.approvalId, e);
+                break;
+            case "question_asked":
+                noteCall(e.payload.step, e.payload.callId);
+                questions.set(e.payload.callId, e);
+                break;
+            case "question_answered":
+                answers.set(e.payload.questionId, e);
+                break;
+            case "subagent_dispatched":
+                dispatches.set(e.payload.callId, e);
+                break;
+            case "subagent_finished":
+                childEnds.set(e.payload.childRunId, e);
+                break;
+            case "hook_denied":
+                if (e.payload.callId !== undefined) {
+                    noteCall(e.payload.step, e.payload.callId);
+                    toolDenials.set(e.payload.callId, e);
+                }
+                else {
+                    steps.add(e.payload.step);
+                    modelDenials.set(e.payload.step, e);
+                }
+                break;
+            default:
+                break;
+        }
+    }
+    const totals = {
+        usage: zeroUsage(),
+        cost: 0,
+        modelCalls: 0,
+        toolCalls: 0,
+        durationMs: endEvent === undefined ? null : ms(started.createdAt, endEvent.createdAt),
+    };
+    const out = [...steps]
+        .sort((a, b) => a - b)
+        .map((step) => {
+        const calls = modelCalls.get(step) ?? [];
+        // 回复与用量按该步最后一次 model_call 之后的第一条配对（步骤被重新发起时，较早的属于之前的尝试）
+        const after = calls.at(-1)?.seq ?? Number.NEGATIVE_INFINITY;
+        const msg = assistants.get(step)?.find((x) => x.seq > after);
+        const u = usages.get(step)?.find((x) => x.seq > after);
+        const modelOut = calls.map((c, i) => {
+            const last = i === calls.length - 1;
+            const ok = last && u !== undefined;
+            const callUsage = ok ? usageOf(u.payload) : null;
+            const cost = callUsage === null
+                ? null
+                : costOf(callUsage, prices.get(priceKey(c.payload.provider, c.payload.model)));
+            return {
+                seq: c.seq,
+                step,
+                attempt: c.payload.attempt,
+                provider: c.payload.provider,
+                model: c.payload.model,
+                fallback: c.payload.fallback,
+                startedAt: iso(c.createdAt),
+                latencyMs: ok ? ms(c.createdAt, u.createdAt) : null,
+                outcome: ok ? "ok" : last && msg === undefined && end === null ? "pending" : "failed",
+                usage: callUsage,
+                cost,
+                request: c.payload.request,
+            };
+        });
+        // 工具调用：以模型回复里的 tool_call 块为准（带 input），其后补上日志里出现但不在块里的调用
+        const blocks = (msg?.payload.content ?? []).flatMap((b) => b.type === "tool_call" ? [b] : []);
+        const ids = blocks.map((b) => b.id);
+        for (const id of stepCalls.get(step) ?? [])
+            if (!ids.includes(id))
+                ids.push(id);
+        const toolOut = ids.map((callId) => {
+            const block = blocks.find((b) => b.id === callId);
+            const startedEv = toolStarts.get(callId);
+            const res = toolResults.get(callId);
+            const ap = approvals.get(callId);
+            const dec = ap === undefined ? undefined : decisions.get(ap.payload.approvalId);
+            const q = questions.get(callId);
+            const ans = q === undefined ? undefined : answers.get(q.payload.questionId);
+            const denied = toolDenials.get(callId);
+            const dispatch = dispatches.get(callId)?.payload;
+            return {
+                ...(denied !== undefined && { hookDenied: denialOf(denied) }),
+                ...(dispatch !== undefined && {
+                    subagent: {
+                        subagentId: dispatch.subagentId,
+                        childRunId: dispatch.childRunId,
+                        agentType: dispatch.agentType,
+                        resumed: dispatch.resumed,
+                        status: childEnds.get(dispatch.childRunId)?.payload.status ?? "running",
+                    },
+                }),
+                callId,
+                step,
+                toolKey: startedEv?.payload.toolKey ??
+                    res?.payload.toolKey ??
+                    ap?.payload.toolKey ??
+                    block?.name ??
+                    "",
+                input: block?.input ?? null,
+                startedAt: startedEv === undefined ? null : iso(startedEv.createdAt),
+                durationMs: startedEv !== undefined && res !== undefined
+                    ? ms(startedEv.createdAt, res.createdAt)
+                    : null,
+                result: res === undefined
+                    ? null
+                    : {
+                        content: res.payload.content,
+                        isError: res.payload.isError,
+                        ...(res.payload.outputId !== undefined && { outputId: res.payload.outputId }),
+                    },
+                approval: ap === undefined
+                    ? null
+                    : {
+                        approvalId: ap.payload.approvalId,
+                        requestedAt: iso(ap.createdAt),
+                        decision: dec?.payload.decision ?? null,
+                        ...(dec?.payload.scope !== undefined && { scope: dec.payload.scope }),
+                        byAccountId: dec?.payload.byAccountId ?? null,
+                        decidedAt: dec === undefined ? null : iso(dec.createdAt),
+                    },
+                question: q === undefined
+                    ? null
+                    : {
+                        questionId: q.payload.questionId,
+                        askedAt: iso(q.createdAt),
+                        outcome: ans?.payload.outcome ?? null,
+                        byAccountId: ans?.payload.byAccountId ?? null,
+                    },
+            };
+        });
+        for (const c of modelOut) {
+            totals.modelCalls++;
+            if (c.usage === null)
+                continue;
+            totals.usage.inputTokens += c.usage.inputTokens;
+            totals.usage.outputTokens += c.usage.outputTokens;
+            totals.usage.cacheReadTokens += c.usage.cacheReadTokens;
+            totals.usage.cacheWriteTokens += c.usage.cacheWriteTokens;
+            totals.cost = totals.cost === null || c.cost === null ? null : totals.cost + c.cost;
+        }
+        totals.toolCalls += toolOut.length;
+        const modelDenied = modelDenials.get(step);
+        return {
+            step,
+            ...(modelDenied !== undefined && {
+                modelHookDenied: {
+                    ...denialOf(modelDenied),
+                    ...(modelDenied.payload.attempt !== undefined && {
+                        attempt: modelDenied.payload.attempt,
+                    }),
+                },
+            }),
+            modelCalls: modelOut,
+            toolCalls: toolOut,
+            text: (msg?.payload.content ?? [])
+                .flatMap((b) => (b.type === "text" ? [b.text] : []))
+                .join(""),
+            stopReason: msg?.payload.stopReason ?? null,
+        };
+    });
+    for (const c of compactions) {
+        const u = usageOf(c.payload);
+        totals.usage.inputTokens += u.inputTokens;
+        totals.usage.outputTokens += u.outputTokens;
+        totals.usage.cacheReadTokens += u.cacheReadTokens;
+        totals.usage.cacheWriteTokens += u.cacheWriteTokens;
+        const cost = costOf(u, prices.get(priceKey(c.payload.provider, c.payload.model)));
+        totals.cost = totals.cost === null || cost === null ? null : totals.cost + cost;
+    }
+    const skillFork = skillForkOf(events, forks);
+    return {
+        runId,
+        agentVersion: started.payload.agentVersion,
+        triggerAccountId: started.payload.triggerAccountId,
+        startedAt: iso(started.createdAt),
+        endedAt: endEvent === undefined ? null : iso(endEvent.createdAt),
+        end,
+        ...(skillFork !== undefined && { skillFork }),
+        steps: out,
+        totals,
+    };
+}

package/dist/evals/trajectory.service.d.ts

@@ -0,0 +1,108 @@
+import type { EventLog } from "../conversations/event-log.js";
+import type { ConversationKind, KernelDb } from "../db/kernel-schema.js";
+import type { SettingsService } from "../identity/settings.js";
+import type { PricesService } from "../models/prices.js";
+import { type TrajectoryRun } from "./trajectory.js";
+/** 轨迹列表的一项（不含对话内容，列表不写审计）。 */
+export interface TrajectoryListItem {
+    conversationId: string;
+    agentId: string;
+    agentName: string;
+    accountId: string;
+    title: string | null;
+    updatedAt: string;
+    lastRun: {
+        runId: string;
+        status: string;
+        startedAt: string | null;
+    } | null;
+}
+export interface TrajectoryDetail {
+    conversation: {
+        id: string;
+        agentId: string;
+        accountId: string;
+        title: string | null;
+        kind: ConversationKind;
+        /**
+         * A sub-agent's conversation (phase C, spec §15.4): the parent conversation and the `agent`
+         * call that first dispatched it, for the link back. Visible exactly when the child is (the
+         * child's access is its parent's).
+         */
+        parent?: {
+            conversationId: string;
+            runId: string;
+            callId: string;
+        };
+    };
+    runs: TrajectoryRun[];
+    /** 成本的币种（部署设置 `priceCurrency`）。 */
+    currency: string;
+    /**
+     * 只在按运行分页（给了 `limit` / `before`）时出现：更早一页的游标（本页最早一次运行的 id，作为 `before`
+     * 传回）；没有更早的运行时为 null。给 `runId` 时总是 null。不带窗口时没有这个字段（形状与以前一致）。
+     */
+    next?: string | null;
+}
+/** 轨迹详情的运行窗口：`runId` 只取一次运行；否则取 `before` 之前（不传为最新）的 `limit` 次运行。 */
+export type RunWindow = {
+    runId: string;
+} | {
+    before?: string;
+    limit: number;
+};
+/** 运行的状态（`runs.status`），列表按最近一次运行的状态过滤用。 */
+export declare const RUN_STATUSES: readonly ["queued", "running", "waiting", "completed", "failed", "aborted"];
+export type RunStatus = (typeof RUN_STATUSES)[number];
+/**
+ * 轨迹查看器（D6、C1）：只给组织管理员（admin / owner）与 agent 负责人。负责人与角色每次实时读（R5）；
+ * 无权查看与不存在一律 `trajectory.not_found`，不泄露对话是否存在。每次查看详情写审计 `trajectory.viewed`。
+ * 企业管理员不因身份而能看（不是组织成员时 OrgGuard 已 404）。
+ *
+ * 列表按 `conversations.kind` 过滤，不传时只列 `chat`（评测回放的隐藏对话用 `kind: "eval"` 列出）。
+ * 评测对话（`kind = 'eval'`）只给组织管理员（Ruling S1-c）：里面是管理员的候选指令，非管理员的 agent 负责人
+ * 列不出、读详情 404。
+ */
+export declare class TrajectoryService {
+    private readonly db;
+    private readonly eventLog;
+    private readonly prices;
+    private readonly settings;
+    constructor(db: KernelDb, eventLog: EventLog, prices: PricesService, settings: SettingsService);
+    /** 调用者当前在组织里的角色；不是成员或组织已删除 → null。 */
+    private role;
+    /** 至少是 member（guest 不能看轨迹）。 */
+    private static isMember;
+    /** 组织 admin / owner，或该 agent 当前的负责人（且至少是 member）。agent 已删除或不在本组织 → false。 */
+    canView(orgId: string, accountId: string, agentId: string): Promise<boolean>;
+    /**
+     * 列出可查看的对话（admin 看全部，其余只看自己负责的 agent），按 (updated_at, id) 倒序；`kind` 缺省为 `chat`。
+     * `before` 是上一页的 `next`（对话 id）：从该对话当前的 (updated_at, id) 之后继续。
+     */
+    list(orgId: string, accountId: string, q: {
+        agentId?: string;
+        kind?: "chat" | "eval";
+        /** 只列最近一次运行是该状态的对话（没有运行的对话不列）。 */
+        status?: RunStatus;
+        before?: string;
+        limit: number;
+    }): Promise<{
+        items: TrajectoryListItem[];
+        next: string | null;
+    }>;
+    /**
+     * 一个对话的轨迹；无权或不存在 → `trajectory.not_found`。成功时（含窗口为空）写审计 `trajectory.viewed`。
+     * 不给 `window` 时读全对话；给了只读窗口内（且已开始）的运行的事件，响应带 `next`。
+     */
+    get(orgId: string, accountId: string, conversationId: string, actorTokenId?: string, window?: RunWindow): Promise<TrajectoryDetail>;
+    /** The parent call that first dispatched a sub-agent conversation. */
+    private firstDispatch;
+    /** The agent of a sub-agent conversation's parent conversation, or null. */
+    private parentAgentId;
+    /**
+     * 窗口内已开始（`started_at` 非空，与轨迹只列有 `run_started` 的运行一致）的运行，按 (created_at, id) 倒序取
+     * `limit` 次；`before` 是上一页的 `next`（运行 id）。`next`：还有更早的运行时为本页最早一次的 id。
+     * `runId` / `before` 不是本对话里已开始的运行 → `trajectory.not_found`（调用方在写审计之前调用）。
+     */
+    private windowRuns;
+}