@botbotgo/agent-harness 0.0.156 → 0.0.158

package/README.md

@@ -450,10 +450,18 @@ const result = await run(runtime, {
     onEvent(event) {
       console.log(event.eventType, event.payload);
     },
+    onUpstreamEvent(event) {
+      console.log("raw upstream event", event);
+    },
+    onUpstreamItem(item) {
+      console.log("upstream agent", item.agentId, item.event);
+    },
   },
 });
 ```
 
+`onUpstreamEvent(...)` preserves the raw upstream event payload. `onUpstreamItem(...)` adds runtime correlation metadata such as `threadId`, `runId`, and the current `agentId`, which is useful for flow-graph capture and delegated sub-agent inspection.
+
 `subscribe(...)` is the read-only observer surface over stored lifecycle events.
 
 The runtime event stream includes:
@@ -563,8 +571,14 @@ Discovery rules:
 - local tools are auto-discovered from `resources/tools/**/*.js|*.mjs|*.cjs` when they export `tool({...})`
 - skills are auto-discovered from `resources/skills/**/SKILL.md`
 
+Example workspaces:
+
+- `examples/hello-skill-app/` keeps the smallest local tool + skill workspace
+- `examples/runtime-flow-demo/` runs one real hosted-model request and exports a Mermaid flowchart from runtime plus upstream events
+
 Workspace-local tool modules in `resources/tools/` should be exported with `tool({...})`.
 Any other local module shape is not supported, and unsupported shapes are rejected at load time.
+When local tools use Zod-authored schemas, keep the workspace or isolated `resources` package on `zod@^4` so raw-shape validators and runtime parsing stay on one supported major version.
 
 Default wiring guidance:
 
@@ -796,10 +810,15 @@ spec:
       rootDir: .
       virtualMode: true
       maxFileSizeMb: 10
+      sessionStorage:
+        enabled: true
+        rootDir: "{runRoot}/threads/{threadId}/filesystem"
     middleware: []
     systemPrompt: Answer simple requests directly.
 ```
 
+When `config.filesystem.sessionStorage.enabled: true` is set for a LangChain binding, the runtime keeps one filesystem root per persisted session/thread and reuses the same runnable cache entry for repeated work on that session instead of collapsing every run onto one shared workspace directory.
+
 Example orchestra host:
 
 ```yaml
@@ -860,6 +879,23 @@ Primary exports:
 - `deleteSession`
 - `listApprovals`
 - `getApproval`
+- `listArtifacts`
+- `getArtifact`
+- `exportEvaluationBundle`
+- `createAcpServer`
 - `createToolMcpServer`
 - `serveToolsOverStdio`
 - `stop`
+- `createUpstreamTimelineReducer`
+- `buildFlowGraph`
+- `exportFlowGraphToMermaid`
+- `exportFlowGraphToSequenceMermaid`
+
+Inspection helpers:
+
+- `createUpstreamTimelineReducer()` reduces raw upstream model/tool/chain events into ordered step-like projections for inspection and visualization.
+- `buildFlowGraph(...)` combines persisted runtime timeline items with optional upstream projections into a detailed flow graph utility shape, including best-effort delegated subagent transitions when raw upstream events are available.
+- `exportFlowGraphToMermaid(...)` renders that inspection graph as Mermaid flowchart text. By default it emits the product view: agent and sub-agent delegation plus user-defined model, tool, and skill calls. Use `view: "debug"` to include runtime inspection detail.
+- `exportFlowGraphToSequenceMermaid(...)` renders the same inspection graph as a Mermaid sequence diagram. By default it emits only user-defined participants and calls, while `view: "debug"` includes runtime participants and lifecycle messages.
+
+These helpers are visualization and inspection utilities. They do not introduce a canonical harness-owned execution protocol.

package/README.zh.md

@@ -535,8 +535,14 @@ await stop(runtime);
 - 本地工具会从 `resources/tools/**/*.js|*.mjs|*.cjs` 中自动发现，前提是模块导出 `tool({...})`
 - skills 会从 `resources/skills/**/SKILL.md` 自动发现
 
+示例工作区：
+
+- `examples/hello-skill-app/` 保留最小的本地 tool + skill 工作区
+- `examples/runtime-flow-demo/` 会跑一次真实 hosted model 请求，并把 runtime 与 upstream events 导出为 Mermaid flowchart
+
 `resources/tools/` 下的工作区本地工具模块应统一用 `tool({...})` 导出。
 不支持历史/兼容写法，任何不带该导出形式的工具模块都会在工作区加载时被拒绝。
+若本地工具使用 Zod schema，请让工作区或隔离的 `resources` 包统一使用 `zod@^4`，避免 raw shape validator 与 runtime 解析落在不同 major 版本上。
 
 主要有三层配置：
 
@@ -763,10 +769,15 @@ spec:
       rootDir: .
       virtualMode: true
       maxFileSizeMb: 10
+      sessionStorage:
+        enabled: true
+        rootDir: "{runRoot}/threads/{threadId}/filesystem"
     middleware: []
     systemPrompt: Answer simple requests directly.
 ```
 
+当 LangChain 绑定启用 `config.filesystem.sessionStorage.enabled: true` 时，runtime 会为每个持久化 session/thread 维护独立的 filesystem 根目录，并按 session 复用 runnable cache，而不是把所有运行都压到同一个共享工作目录里。
+
 orchestra 主机示例：
 
 ```yaml
@@ -827,6 +838,23 @@ spec:
 - `deleteSession`
 - `listApprovals`
 - `getApproval`
+- `listArtifacts`
+- `getArtifact`
+- `exportEvaluationBundle`
+- `createAcpServer`
 - `createToolMcpServer`
 - `serveToolsOverStdio`
 - `stop`
+- `createUpstreamTimelineReducer`
+- `buildFlowGraph`
+- `exportFlowGraphToMermaid`
+- `exportFlowGraphToSequenceMermaid`
+
+Inspection 辅助工具：
+
+- `createUpstreamTimelineReducer()` 可把上游 model/tool/chain 原始事件归约成有序的 step-like 投影，便于检查和可视化。
+- `buildFlowGraph(...)` 可把持久化 runtime timeline 与可选的 upstream projections 组合成详细 flow graph utility 数据结构；当提供原始 upstream events 时，也会尽力补出 subagent delegation 转移。
+- `exportFlowGraphToMermaid(...)` 可把该 inspection graph 导出为 Mermaid flowchart 文本。默认输出 product 视图，只保留 agent / sub-agent delegation 以及用户定义的 model、tool、skill 调用；传 `view: "debug"` 才会带上 runtime 检查细节。
+- `exportFlowGraphToSequenceMermaid(...)` 可把同一份 inspection graph 导出为 Mermaid sequence diagram。默认只输出用户定义的参与者与调用；传 `view: "debug"` 才会包含 runtime participant 与生命周期消息。
+
+这些 helper 只用于可视化与检查，不代表新的 harness 官方执行协议。

package/dist/acp.d.ts

@@ -0,0 +1,86 @@
+import type { ArtifactRecord, HarnessEvent, RequestRecord, RunOptions, SessionRecord } from "./contracts/types.js";
+import type { AgentHarnessRuntime } from "./runtime/harness.js";
+import { getApproval } from "./api.js";
+type JsonRpcId = string | number | null;
+export type AcpJsonRpcRequest = {
+    jsonrpc?: "2.0";
+    id?: JsonRpcId;
+    method: string;
+    params?: unknown;
+};
+export type AcpJsonRpcError = {
+    jsonrpc: "2.0";
+    id: JsonRpcId;
+    error: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+};
+export type AcpJsonRpcSuccess = {
+    jsonrpc: "2.0";
+    id: JsonRpcId;
+    result: unknown;
+};
+export type AcpJsonRpcResponse = AcpJsonRpcError | AcpJsonRpcSuccess;
+export type AcpSessionRecord = SessionRecord;
+export type AcpRequestRecord = RequestRecord;
+export type AcpApproval = Awaited<ReturnType<typeof getApproval>> extends infer T ? Exclude<T, null> : never;
+export type AcpArtifact = ArtifactRecord & {
+    content?: unknown;
+};
+export type AcpRunRequestParams = Omit<Extract<RunOptions, {
+    input: unknown;
+}>, "threadId"> & {
+    sessionId?: string;
+};
+export type AcpServerCapabilities = {
+    sessions: {
+        list: true;
+        get: true;
+    };
+    requests: {
+        submit: true;
+        list: true;
+        get: true;
+    };
+    approvals: {
+        list: true;
+        get: true;
+        resolve: true;
+    };
+    artifacts: {
+        list: true;
+        read: true;
+    };
+    events: {
+        subscribe: true;
+    };
+};
+export type AcpEventNotification = {
+    jsonrpc: "2.0";
+    method: "events.runtime";
+    params: {
+        event: {
+            eventId: string;
+            eventType: string;
+            timestamp: string;
+            sessionId: string;
+            requestId: string;
+            sequence: number;
+            source: HarnessEvent["source"];
+            payload: Record<string, unknown>;
+        };
+    };
+};
+export declare class AgentHarnessAcpServer {
+    private readonly runtime;
+    constructor(runtime: AgentHarnessRuntime);
+    capabilities(): AcpServerCapabilities;
+    subscribe(listener: (notification: AcpEventNotification) => void): () => void;
+    handle(request: AcpJsonRpcRequest): Promise<AcpJsonRpcResponse | undefined>;
+    private methodExists;
+    private dispatch;
+}
+export declare function createAcpServer(runtime: AgentHarnessRuntime): AgentHarnessAcpServer;
+export {};

package/dist/acp.js

@@ -0,0 +1,208 @@
+import { getApproval, getArtifact, getRequest, getSession, listApprovals, listArtifacts, listRequests, listSessions, resolveApproval, run, } from "./api.js";
+const CAPABILITIES = {
+    sessions: { list: true, get: true },
+    requests: { submit: true, list: true, get: true },
+    approvals: { list: true, get: true, resolve: true },
+    artifacts: { list: true, read: true },
+    events: { subscribe: true },
+};
+function asObject(value, method) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`${method} requires an object params payload.`);
+    }
+    return value;
+}
+function readOptionalString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+function readRequiredString(value, field, method) {
+    const normalized = readOptionalString(value);
+    if (!normalized) {
+        throw new Error(`${method} requires ${field}.`);
+    }
+    return normalized;
+}
+function toNotification(event) {
+    return {
+        jsonrpc: "2.0",
+        method: "events.runtime",
+        params: {
+            event: {
+                eventId: event.eventId,
+                eventType: event.eventType,
+                timestamp: event.timestamp,
+                sessionId: event.threadId,
+                requestId: event.runId,
+                sequence: event.sequence,
+                source: event.source,
+                payload: event.payload,
+            },
+        },
+    };
+}
+async function readArtifactContent(runtime, params) {
+    const method = "artifacts.read";
+    const sessionId = readRequiredString(params.sessionId, "sessionId", method);
+    const requestId = readRequiredString(params.requestId, "requestId", method);
+    const artifactPath = readRequiredString(params.artifactPath, "artifactPath", method);
+    const listing = await listArtifacts(runtime, { sessionId, requestId });
+    const artifact = listing.items.find((item) => item.path === artifactPath);
+    if (!artifact) {
+        throw new Error(`Artifact not found for ${requestId}: ${artifactPath}`);
+    }
+    return {
+        ...artifact,
+        content: await getArtifact(runtime, { sessionId, requestId, artifactPath }),
+    };
+}
+export class AgentHarnessAcpServer {
+    runtime;
+    constructor(runtime) {
+        this.runtime = runtime;
+    }
+    capabilities() {
+        return CAPABILITIES;
+    }
+    subscribe(listener) {
+        return this.runtime.subscribe((event) => {
+            listener(toNotification(event));
+        });
+    }
+    async handle(request) {
+        const id = request.id ?? null;
+        if (!request || typeof request !== "object" || typeof request.method !== "string" || request.method.trim().length === 0) {
+            return {
+                jsonrpc: "2.0",
+                id,
+                error: {
+                    code: -32600,
+                    message: "Invalid JSON-RPC request.",
+                },
+            };
+        }
+        if (request.jsonrpc !== undefined && request.jsonrpc !== "2.0") {
+            return {
+                jsonrpc: "2.0",
+                id,
+                error: {
+                    code: -32600,
+                    message: "Only JSON-RPC 2.0 requests are supported.",
+                },
+            };
+        }
+        try {
+            const result = await this.dispatch(request.method, request.params);
+            if (request.id === undefined) {
+                return undefined;
+            }
+            return {
+                jsonrpc: "2.0",
+                id,
+                result,
+            };
+        }
+        catch (error) {
+            if (request.id === undefined) {
+                return undefined;
+            }
+            return {
+                jsonrpc: "2.0",
+                id,
+                error: {
+                    code: this.methodExists(request.method) ? -32602 : -32601,
+                    message: error instanceof Error ? error.message : "ACP request failed.",
+                },
+            };
+        }
+    }
+    methodExists(method) {
+        return new Set([
+            "capabilities.get",
+            "sessions.list",
+            "sessions.get",
+            "requests.submit",
+            "requests.list",
+            "requests.get",
+            "approvals.list",
+            "approvals.get",
+            "approvals.resolve",
+            "artifacts.list",
+            "artifacts.read",
+        ]).has(method);
+    }
+    async dispatch(method, params) {
+        switch (method) {
+            case "capabilities.get":
+                return this.capabilities();
+            case "sessions.list": {
+                const payload = params === undefined ? {} : asObject(params, method);
+                return listSessions(this.runtime, {
+                    agentId: readOptionalString(payload.agentId),
+                });
+            }
+            case "sessions.get": {
+                const payload = asObject(params, method);
+                return getSession(this.runtime, readRequiredString(payload.sessionId, "sessionId", method));
+            }
+            case "requests.submit": {
+                const payload = asObject(params, method);
+                return run(this.runtime, {
+                    agentId: readOptionalString(payload.agentId),
+                    input: payload.input,
+                    invocation: payload.invocation,
+                    listeners: payload.listeners,
+                    priority: typeof payload.priority === "number" ? payload.priority : undefined,
+                    sessionId: readOptionalString(payload.sessionId),
+                });
+            }
+            case "requests.list": {
+                const payload = params === undefined ? {} : asObject(params, method);
+                return listRequests(this.runtime, {
+                    agentId: readOptionalString(payload.agentId),
+                    sessionId: readOptionalString(payload.sessionId),
+                    state: payload.state,
+                });
+            }
+            case "requests.get": {
+                const payload = asObject(params, method);
+                return getRequest(this.runtime, readRequiredString(payload.requestId, "requestId", method));
+            }
+            case "approvals.list": {
+                const payload = params === undefined ? {} : asObject(params, method);
+                return listApprovals(this.runtime, {
+                    status: payload.status,
+                    sessionId: readOptionalString(payload.sessionId),
+                    requestId: readOptionalString(payload.requestId),
+                });
+            }
+            case "approvals.get": {
+                const payload = asObject(params, method);
+                return getApproval(this.runtime, readRequiredString(payload.approvalId, "approvalId", method));
+            }
+            case "approvals.resolve": {
+                const payload = asObject(params, method);
+                return resolveApproval(this.runtime, {
+                    approvalId: readRequiredString(payload.approvalId, "approvalId", method),
+                    decision: payload.decision,
+                    editedInput: payload.editedInput,
+                    requestId: readOptionalString(payload.requestId),
+                    sessionId: readOptionalString(payload.sessionId),
+                });
+            }
+            case "artifacts.list": {
+                const payload = asObject(params, method);
+                return listArtifacts(this.runtime, {
+                    sessionId: readRequiredString(payload.sessionId, "sessionId", method),
+                    requestId: readRequiredString(payload.requestId, "requestId", method),
+                });
+            }
+            case "artifacts.read":
+                return readArtifactContent(this.runtime, asObject(params, method));
+            default:
+                throw new Error(`Unknown ACP method: ${method}`);
+        }
+    }
+}
+export function createAcpServer(runtime) {
+    return new AgentHarnessAcpServer(runtime);
+}

package/dist/api.d.ts

@@ -1,11 +1,14 @@
-import type { CancelOptions, InvocationEnvelope, ListMemoriesInput, ListMemoriesResult, MemoryRecord, MemorizeInput, MemorizeResult, MessageContent, RecallInput, RecallResult, RemoveMemoryInput, RequestRecord, RequestSummary, ResumeOptions, RunDecisionOptions, RunResult, RunStartOptions, RuntimeHealthSnapshot, RuntimeAdapterOptions, SessionRecord, SessionSummary, UpdateMemoryInput, WorkspaceLoadOptions } from "./contracts/types.js";
+import type { ArtifactListing, CancelOptions, InvocationEnvelope, ListMemoriesInput, ListMemoriesResult, MemoryRecord, MemorizeInput, MemorizeResult, MessageContent, RecallInput, RecallResult, RemoveMemoryInput, RequestRecord, RequestSummary, ResumeOptions, RunDecisionOptions, RunResult, RunStartOptions, RuntimeHealthSnapshot, RuntimeAdapterOptions, RuntimeEvaluationExport, RuntimeEvaluationExportInput, SessionRecord, SessionSummary, UpdateMemoryInput, WorkspaceLoadOptions } from "./contracts/types.js";
 import { AgentHarnessRuntime } from "./runtime/harness.js";
 import type { InventoryAgentRecord, InventorySkillRecord } from "./runtime/harness/system/inventory.js";
 import type { RequirementAssessmentOptions } from "./runtime/harness/system/skill-requirements.js";
 import type { ToolMcpServerOptions } from "./mcp.js";
+export { AgentHarnessAcpServer, createAcpServer } from "./acp.js";
+export type { AcpApproval, AcpArtifact, AcpEventNotification, AcpJsonRpcError, AcpJsonRpcRequest, AcpJsonRpcResponse, AcpJsonRpcSuccess, AcpRequestRecord, AcpRunRequestParams, AcpServerCapabilities, AcpSessionRecord, } from "./acp.js";
 export { AgentHarnessRuntime } from "./runtime/harness.js";
+export { buildFlowGraph, exportFlowGraphToMermaid, exportFlowGraphToSequenceMermaid } from "./flow/index.js";
 export { createUpstreamTimelineReducer } from "./upstream-events.js";
-export type { ListMemoriesInput, ListMemoriesResult, MemoryDecision, MemoryKind, MemoryRecord, MemoryScope, MemorizeInput, MemorizeResult, RecallInput, RecallResult, RemoveMemoryInput, UpdateMemoryInput, } from "./contracts/types.js";
+export type { ListMemoriesInput, ListMemoriesResult, MemoryDecision, MemoryKind, MemoryRecord, MemoryScope, MemorizeInput, MemorizeResult, RecallInput, RecallResult, RemoveMemoryInput, RuntimeEvaluationExport, RuntimeEvaluationExportInput, UpdateMemoryInput, } from "./contracts/types.js";
 type PublicApprovalRecord = {
     approvalId: string;
     pendingActionId: string;
@@ -72,7 +75,17 @@ export declare function getRequest(runtime: AgentHarnessRuntime, requestId: stri
 export declare function deleteSession(runtime: AgentHarnessRuntime, sessionId: string): Promise<boolean>;
 export declare function listApprovals(runtime: AgentHarnessRuntime, filter?: PublicApprovalFilter): Promise<PublicApprovalRecord[]>;
 export declare function getApproval(runtime: AgentHarnessRuntime, approvalId: string): Promise<PublicApprovalRecord | null>;
+export declare function listArtifacts(runtime: AgentHarnessRuntime, input: {
+    sessionId: string;
+    requestId: string;
+}): Promise<ArtifactListing>;
+export declare function getArtifact(runtime: AgentHarnessRuntime, input: {
+    sessionId: string;
+    requestId: string;
+    artifactPath: string;
+}): Promise<unknown>;
 export declare function getHealth(runtime: AgentHarnessRuntime): Promise<RuntimeHealthSnapshot>;
+export declare function exportEvaluationBundle(runtime: AgentHarnessRuntime, input: RuntimeEvaluationExportInput): Promise<RuntimeEvaluationExport>;
 export declare function listAgentSkills(runtime: AgentHarnessRuntime, agentId: string, options?: RequirementAssessmentOptions): InventorySkillRecord[];
 export declare function getAgent(runtime: AgentHarnessRuntime, agentId: string, options?: RequirementAssessmentOptions): InventoryAgentRecord | null;
 export declare function describeInventory(runtime: AgentHarnessRuntime, options?: RequirementAssessmentOptions): {

package/dist/api.js

@@ -1,7 +1,9 @@
 import { AgentHarnessRuntime } from "./runtime/harness.js";
 import { normalizeMessageContent } from "./utils/message-content.js";
 import { loadWorkspace } from "./workspace/compile.js";
+export { AgentHarnessAcpServer, createAcpServer } from "./acp.js";
 export { AgentHarnessRuntime } from "./runtime/harness.js";
+export { buildFlowGraph, exportFlowGraphToMermaid, exportFlowGraphToSequenceMermaid } from "./flow/index.js";
 export { createUpstreamTimelineReducer } from "./upstream-events.js";
 function toSessionSummary(summary) {
     return {
@@ -178,9 +180,18 @@ export async function getApproval(runtime, approvalId) {
     const record = await runtime.getApproval(approvalId);
     return record ? toApprovalRecord(record) : null;
 }
+export async function listArtifacts(runtime, input) {
+    return runtime.listArtifacts(input.sessionId, input.requestId);
+}
+export async function getArtifact(runtime, input) {
+    return runtime.readArtifact(input.sessionId, input.requestId, input.artifactPath);
+}
 export async function getHealth(runtime) {
     return runtime.getHealth();
 }
+export async function exportEvaluationBundle(runtime, input) {
+    return runtime.exportEvaluationBundle(input);
+}
 export function listAgentSkills(runtime, agentId, options) {
     return runtime.listAgentSkills(agentId, options);
 }

package/dist/contracts/runtime.d.ts

@@ -96,6 +96,24 @@ export type RuntimeSnapshotTracing = {
     tags?: string[];
     metadata?: Record<string, unknown>;
 };
+export type RuntimeGovernanceRiskLevel = "low" | "medium" | "high";
+export type RuntimeGovernanceToolPolicy = {
+    toolName: string;
+    toolId: string;
+    toolType: string;
+    category: "local" | "backend" | "mcp" | "provider-native";
+    risk: RuntimeGovernanceRiskLevel;
+    requiresApproval: boolean;
+    approvalPolicy: "explicit-hitl" | "runtime-default" | "none";
+    hasInputSchema: boolean;
+    inputRiskHints: string[];
+};
+export type RuntimeGovernanceBundle = {
+    bundleId: string;
+    title: string;
+    summary: string;
+    toolPolicies: RuntimeGovernanceToolPolicy[];
+};
 export type RuntimeSnapshot = {
     agentId: string;
     model?: RuntimeSnapshotModel;
@@ -103,6 +121,9 @@ export type RuntimeSnapshot = {
     skills: RuntimeSnapshotSkill[];
     memory: string[];
     tracing?: RuntimeSnapshotTracing;
+    governance?: {
+        bundles: RuntimeGovernanceBundle[];
+    };
 };
 export type MemoryCandidate = {
     content: string;
@@ -314,9 +335,16 @@ export type RunResult = {
     metadata?: Record<string, unknown>;
 };
 export type UpstreamRuntimeEvent = unknown;
+export type UpstreamRuntimeEventItem = {
+    threadId: string;
+    runId: string;
+    agentId: string;
+    event: UpstreamRuntimeEvent;
+};
 export type RuntimeListeners = {
     onEvent?: (event: HarnessEvent) => void | Promise<void>;
     onUpstreamEvent?: (event: UpstreamRuntimeEvent) => void | Promise<void>;
+    onUpstreamItem?: (item: UpstreamRuntimeEventItem) => void | Promise<void>;
 };
 export type RunListeners = RuntimeListeners;
 export type MessageContentPart = {
@@ -539,6 +567,7 @@ export type SkillPackagingConvention = {
 export type PolicyDecision = {
     allowed: boolean;
     reasons: string[];
+    bundles?: RuntimeGovernanceBundle[];
 };
 export type PolicyEvaluator = {
     kind: string;
@@ -548,6 +577,32 @@ export type EventSubscriber = {
     kind: string;
     onEvent: HarnessEventListener;
 };
+export type RuntimeEvaluationExportInput = {
+    sessionId: string;
+    requestId: string;
+    includeArtifacts?: boolean;
+    includeArtifactContents?: boolean;
+    expectedOutput?: string;
+    rubric?: string[];
+    tags?: string[];
+    metadata?: Record<string, unknown>;
+};
+export type RuntimeEvaluationArtifact = ArtifactRecord & {
+    content?: unknown;
+};
+export type RuntimeEvaluationExport = {
+    session: SessionRecord | null;
+    request: RequestRecord | null;
+    approvals: ApprovalRecord[];
+    transcript: TranscriptMessage[];
+    events: HarnessEvent[];
+    artifacts: RuntimeEvaluationArtifact[];
+    runtimeHealth: RuntimeHealthSnapshot;
+    expectedOutput?: string;
+    rubric: string[];
+    tags: string[];
+    metadata?: Record<string, unknown>;
+};
 export type RuntimeInventoryContext = {
     workspace: WorkspaceBundle;
 };

package/dist/flow/build-flow-graph.d.ts

@@ -0,0 +1,2 @@
+import type { BuildFlowGraphInput, FlowGraph } from "./types.js";
+export declare function buildFlowGraph(input: BuildFlowGraphInput): FlowGraph;