@botbotgo/agent-harness 0.0.156 → 0.0.157

package/README.md

@@ -796,10 +796,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 +865,10 @@ Primary exports:
 - `deleteSession`
 - `listApprovals`
 - `getApproval`
+- `listArtifacts`
+- `getArtifact`
+- `exportEvaluationBundle`
+- `createAcpServer`
 - `createToolMcpServer`
 - `serveToolsOverStdio`
 - `stop`

package/README.zh.md

@@ -763,10 +763,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 +832,10 @@ spec:
 - `deleteSession`
 - `listApprovals`
 - `getApproval`
+- `listArtifacts`
+- `getArtifact`
+- `exportEvaluationBundle`
+- `createAcpServer`
 - `createToolMcpServer`
 - `serveToolsOverStdio`
 - `stop`

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,13 @@
-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 { 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 +74,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,6 +1,7 @@
 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 { createUpstreamTimelineReducer } from "./upstream-events.js";
 function toSessionSummary(summary) {
@@ -178,9 +179,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;
@@ -539,6 +560,7 @@ export type SkillPackagingConvention = {
 export type PolicyDecision = {
     allowed: boolean;
     reasons: string[];
+    bundles?: RuntimeGovernanceBundle[];
 };
 export type PolicyEvaluator = {
     kind: string;
@@ -548,6 +570,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/index.d.ts

@@ -1,5 +1,6 @@
-export { AgentHarnessRuntime, cancelRun, createAgentHarness, createUpstreamTimelineReducer, createToolMcpServer, deleteSession, describeInventory, getAgent, getApproval, getRequest, getHealth, listMemories, getSession, listAgentSkills, listApprovals, listRequests, listSessions, memorize, normalizeUserChatInput, recall, removeMemory, resolveApproval, run, serveToolsOverStdio, subscribe, stop, updateMemory, } from "./api.js";
-export type { ListMemoriesInput, ListMemoriesResult, MemoryDecision, MemoryKind, MemoryRecord, MemoryScope, MemorizeInput, MemorizeResult, NormalizeUserChatInputOptions, RecallInput, RecallResult, RemoveMemoryInput, UpdateMemoryInput, UserChatInput, UserChatMessage, } from "./api.js";
+export { AgentHarnessAcpServer, AgentHarnessRuntime, cancelRun, createAgentHarness, createAcpServer, createUpstreamTimelineReducer, createToolMcpServer, deleteSession, describeInventory, exportEvaluationBundle, getArtifact, getAgent, getApproval, getRequest, getHealth, listMemories, getSession, listAgentSkills, listArtifacts, listApprovals, listRequests, listSessions, memorize, normalizeUserChatInput, recall, removeMemory, resolveApproval, run, serveToolsOverStdio, subscribe, stop, updateMemory, } from "./api.js";
+export type { AcpApproval, AcpArtifact, AcpEventNotification, AcpJsonRpcError, AcpJsonRpcRequest, AcpJsonRpcResponse, AcpJsonRpcSuccess, AcpRequestRecord, AcpRunRequestParams, AcpServerCapabilities, AcpSessionRecord, } from "./acp.js";
+export type { ListMemoriesInput, ListMemoriesResult, MemoryDecision, MemoryKind, MemoryRecord, MemoryScope, MemorizeInput, MemorizeResult, NormalizeUserChatInputOptions, RecallInput, RecallResult, RemoveMemoryInput, RuntimeEvaluationExport, RuntimeEvaluationExportInput, UpdateMemoryInput, UserChatInput, UserChatMessage, } from "./api.js";
 export type { ToolMcpServerOptions } from "./mcp.js";
 export { tool } from "./tools.js";
 export type { UpstreamTimelineProjection, UpstreamTimelineReducer } from "./upstream-events.js";

package/dist/index.js

@@ -1,2 +1,2 @@
-export { AgentHarnessRuntime, cancelRun, createAgentHarness, createUpstreamTimelineReducer, createToolMcpServer, deleteSession, describeInventory, getAgent, getApproval, getRequest, getHealth, listMemories, getSession, listAgentSkills, listApprovals, listRequests, listSessions, memorize, normalizeUserChatInput, recall, removeMemory, resolveApproval, run, serveToolsOverStdio, subscribe, stop, updateMemory, } from "./api.js";
+export { AgentHarnessAcpServer, AgentHarnessRuntime, cancelRun, createAgentHarness, createAcpServer, createUpstreamTimelineReducer, createToolMcpServer, deleteSession, describeInventory, exportEvaluationBundle, getArtifact, getAgent, getApproval, getRequest, getHealth, listMemories, getSession, listAgentSkills, listArtifacts, listApprovals, listRequests, listSessions, memorize, normalizeUserChatInput, recall, removeMemory, resolveApproval, run, serveToolsOverStdio, subscribe, stop, updateMemory, } from "./api.js";
 export { tool } from "./tools.js";

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.155";
+export declare const AGENT_HARNESS_VERSION = "0.0.156";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.155";
+export const AGENT_HARNESS_VERSION = "0.0.156";

package/dist/persistence/file-store.d.ts

@@ -69,6 +69,7 @@ export declare class FilePersistence implements RuntimePersistence {
     resolveApproval(threadId: string, runId: string, approvalId: string, status: InternalApprovalRecord["status"]): Promise<InternalApprovalRecord>;
     createArtifact(threadId: string, runId: string, artifact: ArtifactRecord, content: unknown): Promise<ArtifactRecord>;
     listArtifacts(threadId: string, runId: string): Promise<ArtifactListing>;
+    readArtifact(threadId: string, runId: string, artifactPath: string): Promise<unknown>;
     appendThreadMessage(threadId: string, message: TranscriptMessage): Promise<void>;
     listThreadMessages(threadId: string, limit?: number): Promise<TranscriptMessage[]>;
     saveRecoveryIntent(threadId: string, runId: string, intent: RecoveryIntent): Promise<void>;

package/dist/persistence/file-store.js

@@ -328,7 +328,9 @@ export class FilePersistence {
         if (!(await fileExists(eventsDir))) {
             return [];
         }
-        const entries = (await readdir(eventsDir)).sort();
+        const entries = (await readdir(eventsDir))
+            .filter((entry) => entry.endsWith(".json"))
+            .sort((left, right) => left.localeCompare(right));
         return Promise.all(entries.map((entry) => readJson(path.join(eventsDir, entry))));
     }
     async listApprovals(filter = {}) {
@@ -460,6 +462,13 @@ export class FilePersistence {
     async listArtifacts(threadId, runId) {
         return readJson(path.join(this.runDir(threadId, runId), "artifacts.json"));
     }
+    async readArtifact(threadId, runId, artifactPath) {
+        const filePath = path.join(this.runDir(threadId, runId), artifactPath);
+        if (!(await fileExists(filePath))) {
+            return null;
+        }
+        return readJson(filePath);
+    }
     async appendThreadMessage(threadId, message) {
         const messagesPath = path.join(this.threadDir(threadId), "messages.json");
         const current = (await fileExists(messagesPath))

package/dist/persistence/types.d.ts

@@ -120,6 +120,7 @@ export interface RuntimePersistence {
     }): Promise<void>;
     setRunState(threadId: string, runId: string, state: RunState, checkpointRef?: string | null): Promise<void>;
     appendEvent(event: HarnessEvent): Promise<void>;
+    listRunEvents(threadId: string, runId: string): Promise<HarnessEvent[]>;
     listSessions(filter?: ThreadSummaryFilter): Promise<ThreadSummary[]>;
     listRuns(filter?: RunSummaryFilter): Promise<RunSummary[]>;
     getRun(runId: string): Promise<RunSummary | null>;
@@ -147,6 +148,7 @@ export interface RuntimePersistence {
     resolveApproval(threadId: string, runId: string, approvalId: string, status: InternalApprovalRecord["status"]): Promise<InternalApprovalRecord>;
     createArtifact(threadId: string, runId: string, artifact: ArtifactRecord, content: unknown): Promise<ArtifactRecord>;
     listArtifacts(threadId: string, runId: string): Promise<ArtifactListing>;
+    readArtifact(threadId: string, runId: string, artifactPath: string): Promise<unknown>;
     appendThreadMessage(threadId: string, message: TranscriptMessage): Promise<void>;
     listThreadMessages(threadId: string, limit?: number): Promise<TranscriptMessage[]>;
     saveRecoveryIntent(threadId: string, runId: string, intent: RecoveryIntent): Promise<void>;

package/dist/runtime/agent-runtime-adapter.d.ts

@@ -63,6 +63,7 @@ export declare class AgentRuntimeAdapter {
     private resolveTools;
     private getToolNameMapping;
     private resolveFilesystemBackend;
+    private resolveFilesystemRootDir;
     private resolveBuiltinMiddlewareBackend;
     private createDeclaredMiddlewareResolverOptions;
     private createAssemblyResolvers;
@@ -75,7 +76,10 @@ export declare class AgentRuntimeAdapter {
     private createLangChainRunnable;
     private createRunnable;
     private createDeepAgentRunnable;
-    create(binding: CompiledAgentBinding): Promise<RunnableLike>;
+    private buildRunnableCacheKey;
+    create(binding: CompiledAgentBinding, options?: {
+        threadId?: string;
+    }): Promise<RunnableLike>;
     invoke(binding: CompiledAgentBinding, input: MessageContent, threadId: string, runId: string, resumePayload?: unknown, history?: TranscriptMessage[], options?: {
         context?: Record<string, unknown>;
         state?: Record<string, unknown>;

package/dist/runtime/agent-runtime-adapter.js

@@ -159,7 +159,7 @@ function shouldAttachMinimalDeepAgentBackend(binding) {
 export class AgentRuntimeAdapter {
     options;
     modelCache = new Map();
-    runnableCache = new WeakMap();
+    runnableCache = new Map();
     toolNameMappingCache = new WeakMap();
     constructor(options = {}) {
         this.options = options;
@@ -213,7 +213,12 @@ export class AgentRuntimeAdapter {
         }
     }
     invalidateBindingRuntimeCaches(binding) {
-        this.runnableCache.delete(binding);
+        const prefix = `${binding.agent.sourcePath}::`;
+        for (const key of Array.from(this.runnableCache.keys())) {
+            if (key.startsWith(prefix)) {
+                this.runnableCache.delete(key);
+            }
+        }
         this.modelCache.clear();
     }
     resolveTools(tools, binding) {
@@ -232,15 +237,19 @@ export class AgentRuntimeAdapter {
         this.toolNameMappingCache.set(binding, resolved);
         return resolved;
     }
-    resolveFilesystemBackend(binding) {
+    resolveFilesystemBackend(binding, options = {}) {
         const filesystemConfig = getBindingFilesystemConfig(binding);
+        const sessionStorage = typeof filesystemConfig?.sessionStorage === "object" && filesystemConfig.sessionStorage
+            ? filesystemConfig.sessionStorage
+            : undefined;
         const configuredRootDir = typeof filesystemConfig?.rootDir === "string" && filesystemConfig.rootDir.trim().length > 0
             ? filesystemConfig.rootDir
             : undefined;
         const workspaceRoot = binding.harnessRuntime.workspaceRoot;
-        const rootDir = configuredRootDir
+        const baseRootDir = configuredRootDir
             ? (path.isAbsolute(configuredRootDir) ? configuredRootDir : path.resolve(workspaceRoot ?? process.cwd(), configuredRootDir))
             : workspaceRoot ?? process.cwd();
+        const rootDir = this.resolveFilesystemRootDir(baseRootDir, binding, sessionStorage, options.threadId);
         return new FilesystemBackend({
             rootDir,
             virtualMode: filesystemConfig?.virtualMode === true,
@@ -249,6 +258,25 @@ export class AgentRuntimeAdapter {
                 : 10,
         });
     }
+    resolveFilesystemRootDir(baseRootDir, binding, sessionStorage, threadId) {
+        const enabled = sessionStorage?.enabled === true;
+        if (!enabled || !threadId) {
+            return baseRootDir;
+        }
+        const workspaceRoot = binding.harnessRuntime.workspaceRoot ?? process.cwd();
+        const runRoot = binding.harnessRuntime.runRoot;
+        const configuredRootDir = typeof sessionStorage.rootDir === "string" && sessionStorage.rootDir.trim().length > 0
+            ? sessionStorage.rootDir.trim()
+            : "{runRoot}/threads/{threadId}/filesystem";
+        const rendered = configuredRootDir
+            .replaceAll("{threadId}", threadId)
+            .replaceAll("{sessionId}", threadId)
+            .replaceAll("{agentId}", binding.agent.id)
+            .replaceAll("{runRoot}", runRoot)
+            .replaceAll("{workspaceRoot}", workspaceRoot)
+            .replaceAll("{baseRootDir}", baseRootDir);
+        return path.isAbsolute(rendered) ? rendered : path.resolve(workspaceRoot, rendered);
+    }
     resolveBuiltinMiddlewareBackend(binding, options = {}) {
         return resolveBuiltinMiddlewareBackendHelper({
             binding,
@@ -257,7 +285,7 @@ export class AgentRuntimeAdapter {
             options,
         });
     }
-    createDeclaredMiddlewareResolverOptions(binding) {
+    createDeclaredMiddlewareResolverOptions(binding, options = {}) {
         return {
             resolveModel: (model) => this.resolveModel(model),
             resolveBackend: (resolvedBinding) => {
@@ -266,7 +294,7 @@ export class AgentRuntimeAdapter {
             },
             resolveFilesystemBackend: (resolvedBinding) => {
                 const targetBinding = resolvedBinding ?? binding;
-                return targetBinding ? this.resolveFilesystemBackend(targetBinding) : undefined;
+                return targetBinding ? this.resolveFilesystemBackend(targetBinding, { threadId: options.threadId }) : undefined;
             },
             resolveCustom: this.options.declaredMiddlewareResolver,
             binding,
@@ -276,8 +304,8 @@ export class AgentRuntimeAdapter {
         return {
             resolveModel: (model) => this.resolveModel(model),
             resolveTools: (tools, currentBinding) => this.resolveTools(tools, currentBinding),
-            resolveFilesystemBackend: (currentBinding) => this.resolveFilesystemBackend(currentBinding),
-            createDeclaredMiddlewareResolverOptions: (currentBinding) => this.createDeclaredMiddlewareResolverOptions(currentBinding),
+            resolveFilesystemBackend: (currentBinding) => this.resolveFilesystemBackend(currentBinding, { threadId: options.threadId }),
+            createDeclaredMiddlewareResolverOptions: (currentBinding) => this.createDeclaredMiddlewareResolverOptions(currentBinding, options),
             resolveBuiltinMiddlewareBackend: (currentBinding, currentOptions = {}) => this.resolveBuiltinMiddlewareBackend(currentBinding, currentOptions),
             resolveSubagents: (subagents, currentBinding) => this.resolveSubagents(subagents, currentBinding),
             invokeBuiltinTaskTool: (currentBinding, toolInput, currentOptions = {}) => this.invokeBuiltinTaskTool(currentBinding, toolInput, currentOptions),
@@ -313,8 +341,8 @@ export class AgentRuntimeAdapter {
             createDeclaredMiddlewareResolverOptions: assembly.createDeclaredMiddlewareResolverOptions,
         });
     }
-    async resolveLangChainRuntimeExtensionMiddleware(binding) {
-        const assembly = this.createAssemblyResolvers(binding);
+    async resolveLangChainRuntimeExtensionMiddleware(binding, options = {}) {
+        const assembly = this.createAssemblyResolvers(binding, options);
         return resolveLangChainRuntimeExtensionMiddlewareHelper({
             binding,
             materializeAutomaticSummarizationMiddleware: (currentBinding) => this.materializeAutomaticSummarizationMiddleware(currentBinding),
@@ -324,14 +352,14 @@ export class AgentRuntimeAdapter {
             resolveSubagents: assembly.resolveSubagents,
         });
     }
-    async resolveMiddleware(binding, interruptOn) {
-        const assembly = this.createAssemblyResolvers(binding);
+    async resolveMiddleware(binding, interruptOn, options = {}) {
+        const assembly = this.createAssemblyResolvers(binding, options);
         return resolveMiddlewareHelper({
             binding,
             interruptOn,
             runtimeAdapterOptions: this.options,
             createDeclaredMiddlewareResolverOptions: assembly.createDeclaredMiddlewareResolverOptions,
-            resolveLangChainRuntimeExtensionMiddleware: (currentBinding) => this.resolveLangChainRuntimeExtensionMiddleware(currentBinding),
+            resolveLangChainRuntimeExtensionMiddleware: (currentBinding) => this.resolveLangChainRuntimeExtensionMiddleware(currentBinding, options),
         });
     }
     async resolveSubagents(subagents, binding) {
@@ -354,7 +382,7 @@ export class AgentRuntimeAdapter {
         const interruptOn = resolveRunnableInterruptOn(binding);
         const resolvedModel = await this.resolveModel(primaryModel);
         const resolvedTools = this.resolveTools(primaryTools, binding);
-        const resolvedMiddleware = await this.resolveMiddleware(binding, interruptOn);
+        const resolvedMiddleware = await this.resolveMiddleware(binding, interruptOn, { threadId: options.threadId });
         const resolvedCheckpointer = resolveRunnableCheckpointer(this.options, binding);
         const resolvedStore = this.options.storeResolver?.(binding);
         const model = resolvedModel;
@@ -372,12 +400,12 @@ export class AgentRuntimeAdapter {
             systemPromptOverride: options.systemPromptOverride,
         }));
     }
-    async createRunnable(binding) {
+    async createRunnable(binding, options = {}) {
         if (getBindingAdapterKind(binding) === "langgraph") {
             throw new Error(`Agent ${binding.agent.id} uses removed backend langgraph; use langchain-v1 or deepagent`);
         }
         if (isLangChainBinding(binding)) {
-            return this.createLangChainRunnable(binding);
+            return this.createLangChainRunnable(binding, { threadId: options.threadId });
         }
         return this.createDeepAgentRunnable(binding);
     }
@@ -425,25 +453,34 @@ export class AgentRuntimeAdapter {
         });
         return createDeepAgent(deepAgentConfig);
     }
-    async create(binding) {
-        const cached = this.runnableCache.get(binding);
+    buildRunnableCacheKey(binding, threadId) {
+        const filesystemConfig = getBindingFilesystemConfig(binding);
+        const sessionStorage = typeof filesystemConfig?.sessionStorage === "object" && filesystemConfig.sessionStorage
+            ? filesystemConfig.sessionStorage
+            : undefined;
+        const sessionScoped = sessionStorage?.enabled === true;
+        return `${binding.agent.sourcePath}::${sessionScoped ? (threadId ?? "__default__") : "__binding__"}`;
+    }
+    async create(binding, options = {}) {
+        const cacheKey = this.buildRunnableCacheKey(binding, options.threadId);
+        const cached = this.runnableCache.get(cacheKey);
         if (cached) {
             return cached;
         }
-        const pending = this.createRunnable(binding);
-        this.runnableCache.set(binding, pending);
+        const pending = this.createRunnable(binding, options);
+        this.runnableCache.set(cacheKey, pending);
         try {
             return await pending;
         }
         catch (error) {
-            this.runnableCache.delete(binding);
+            this.runnableCache.delete(cacheKey);
             throw error;
         }
     }
     async invoke(binding, input, threadId, runId, resumePayload, history = [], options = {}) {
         const callRuntime = async (activeBinding, activeRequest) => {
             return this.invokeWithProviderRetry(activeBinding, async () => {
-                const runnable = await this.create(activeBinding);
+                const runnable = await this.create(activeBinding, { threadId });
                 return (await this.withTimeout(() => runnable.invoke(activeRequest, resolveLangChainInvocationConfig(activeBinding, {
                     threadId,
                     runId,
@@ -469,7 +506,7 @@ export class AgentRuntimeAdapter {
             invokeOptions: options,
             resolveTools: (tools, currentBinding) => this.resolveTools(tools, currentBinding),
             getToolNameMapping: (currentBinding) => this.getToolNameMapping(currentBinding),
-            resolveBuiltinMiddlewareTools: (currentBinding, currentOptions) => this.resolveBuiltinMiddlewareTools(currentBinding, currentOptions),
+            resolveBuiltinMiddlewareTools: (currentBinding, currentOptions) => this.resolveBuiltinMiddlewareTools(currentBinding, { ...currentOptions, threadId }),
             callRuntimeWithToolParseRecovery,
         });
     }
@@ -494,7 +531,7 @@ export class AgentRuntimeAdapter {
             forceInvokeFallback,
             canUseDirectModelStream,
             langChainStreamModel,
-            createRunnable: () => this.create(binding),
+            createRunnable: () => this.create(binding, { threadId }),
             withTimeout: (producer, timeoutMs, operation, stage) => this.withTimeout(producer, timeoutMs, operation, stage),
             iterateWithTimeout: (iterable, timeoutMs, operation, deadlineAt, deadlineTimeoutMs) => this.iterateWithTimeout(iterable, timeoutMs, operation, deadlineAt, deadlineTimeoutMs),
             invokeTimeoutMs: computeRemainingTimeoutMs(streamDeadlineAt, invokeTimeoutMs),

package/dist/runtime/harness/run/governance.d.ts

@@ -0,0 +1,2 @@
+import type { CompiledAgentBinding, RuntimeGovernanceBundle } from "../../../contracts/types.js";
+export declare function buildRuntimeGovernanceBundles(binding: CompiledAgentBinding): RuntimeGovernanceBundle[];

package/dist/runtime/harness/run/governance.js

@@ -0,0 +1,76 @@
+import { getBindingPrimaryTools } from "../../support/compiled-binding.js";
+import { toolRequiresRuntimeApproval } from "../../adapter/tool/tool-hitl.js";
+const WRITE_LIKE_PATTERN = /\b(write|edit|delete|create|update|append|insert|push|commit|publish|send|post|apply|merge|sync|upload|save)\b/i;
+function inputHints(binding, tool) {
+    const hints = new Set();
+    const target = `${tool.name} ${tool.description}`.toLowerCase();
+    if (/(path|file|dir|directory|folder|workspace|repo|repository)/.test(target)) {
+        hints.add("filesystem-scope");
+    }
+    if (/(memory|knowledge|store|recall)/.test(target)) {
+        hints.add("memory-scope");
+    }
+    if (tool.config?.mcp) {
+        hints.add("remote-mcp");
+    }
+    if (binding.agent.executionMode === "deepagent") {
+        hints.add("delegated-runtime");
+    }
+    return Array.from(hints);
+}
+function classifyRisk(policy) {
+    if (policy.requiresApproval) {
+        return "high";
+    }
+    const target = `${policy.toolName} ${policy.description}`;
+    if (policy.toolType === "mcp" && WRITE_LIKE_PATTERN.test(target)) {
+        return "high";
+    }
+    if (policy.toolType === "backend" || policy.toolType === "mcp") {
+        return "medium";
+    }
+    return "low";
+}
+function toCategory(toolType) {
+    if (toolType === "mcp") {
+        return "mcp";
+    }
+    if (toolType === "backend") {
+        return "backend";
+    }
+    if (toolType === "provider") {
+        return "provider-native";
+    }
+    return "local";
+}
+export function buildRuntimeGovernanceBundles(binding) {
+    const toolPolicies = getBindingPrimaryTools(binding).map((tool) => {
+        const requiresApproval = toolRequiresRuntimeApproval(tool);
+        return {
+            toolName: tool.name,
+            toolId: tool.id,
+            toolType: tool.type,
+            category: toCategory(tool.type),
+            risk: classifyRisk({
+                toolType: tool.type,
+                requiresApproval,
+                toolName: tool.name,
+                description: tool.description,
+                config: tool.config,
+            }),
+            requiresApproval,
+            approvalPolicy: tool.hitl?.enabled === true ? "explicit-hitl" : requiresApproval ? "runtime-default" : "none",
+            hasInputSchema: typeof tool.inputSchemaRef === "string" && tool.inputSchemaRef.trim().length > 0,
+            inputRiskHints: inputHints(binding, tool),
+        };
+    });
+    if (toolPolicies.length === 0) {
+        return [];
+    }
+    return [{
+            bundleId: `governance/${binding.agent.id}`,
+            title: "Runtime tool governance",
+            summary: `${toolPolicies.filter((tool) => tool.requiresApproval).length} of ${toolPolicies.length} tool(s) require approval`,
+            toolPolicies,
+        }];
+}

package/dist/runtime/harness/run/inspection.js

@@ -1,5 +1,6 @@
 import { readSkillMetadata } from "../../support/skill-metadata.js";
 import { getBindingMemorySources, getBindingPrimaryModel, getBindingPrimaryTools, getBindingSkills, getBindingSubagents, } from "../../support/compiled-binding.js";
+import { buildRuntimeGovernanceBundles } from "./governance.js";
 function asObject(value) {
     return typeof value === "object" && value !== null ? value : null;
 }
@@ -67,6 +68,9 @@ export function buildRunRuntimeSnapshot(binding, options) {
             };
         }),
         memory: getBindingMemorySources(binding),
+        governance: {
+            bundles: buildRuntimeGovernanceBundles(binding),
+        },
         ...(tracing ? { tracing } : {}),
     };
 }

package/dist/runtime/harness/system/policy-engine.d.ts

@@ -1,7 +1,8 @@
-import type { CompiledAgentBinding } from "../../../contracts/types.js";
+import type { CompiledAgentBinding, RuntimeGovernanceBundle } from "../../../contracts/types.js";
 export type PolicyEngineDecision = {
     allowed: boolean;
     reasons: string[];
+    bundles?: RuntimeGovernanceBundle[];
 };
 export declare class PolicyEngine {
     /**

package/dist/runtime/harness/system/policy-engine.js

@@ -7,6 +7,7 @@ export class PolicyEngine {
      */
     evaluate(binding) {
         const reasons = [];
+        const bundles = [];
         let allowed = true;
         for (const evaluator of getPolicyEvaluators()) {
             const decision = evaluator.evaluate(binding);
@@ -17,8 +18,11 @@ export class PolicyEngine {
                 allowed = false;
             }
             reasons.push(...decision.reasons);
+            if (Array.isArray(decision.bundles)) {
+                bundles.push(...decision.bundles);
+            }
         }
-        return { allowed, reasons };
+        return bundles.length > 0 ? { allowed, reasons, bundles } : { allowed, reasons };
     }
 }
 export { PolicyEngine as GovernanceEngine, };

package/dist/runtime/harness.d.ts

@@ -1,4 +1,4 @@
-import type { ApprovalRecord, CancelOptions, HarnessEvent, HarnessStreamItem, RuntimeHealthSnapshot, ListMemoriesInput, ListMemoriesResult, MessageContent, RemoveMemoryInput, RunRecord, RunStartOptions, RestartConversationOptions, RuntimeAdapterOptions, ResumeOptions, RunOptions, RunResult, RunSummary, MemoryRecord, MemorizeInput, MemorizeResult, RecallInput, RecallResult, UpdateMemoryInput, ThreadSummary, ThreadRecord, WorkspaceBundle } from "../contracts/types.js";
+import type { ApprovalRecord, ArtifactListing, CancelOptions, HarnessEvent, HarnessStreamItem, RuntimeHealthSnapshot, ListMemoriesInput, ListMemoriesResult, MessageContent, RemoveMemoryInput, RunRecord, RunStartOptions, RestartConversationOptions, RuntimeAdapterOptions, RuntimeEvaluationExport, RuntimeEvaluationExportInput, ResumeOptions, RunOptions, RunResult, RunSummary, MemoryRecord, MemorizeInput, MemorizeResult, RecallInput, RecallResult, UpdateMemoryInput, ThreadSummary, ThreadRecord, WorkspaceBundle } from "../contracts/types.js";
 import { type ToolMcpServerOptions } from "../mcp.js";
 import { type InventoryAgentRecord, type InventorySkillRecord } from "./harness/system/inventory.js";
 import type { RequirementAssessmentOptions } from "./harness/system/skill-requirements.js";
@@ -82,6 +82,10 @@ export declare class AgentHarnessRuntime {
         runId?: string;
     }): Promise<ApprovalRecord[]>;
     getApproval(approvalId: string): Promise<ApprovalRecord | null>;
+    listArtifacts(threadId: string, runId: string): Promise<ArtifactListing>;
+    readArtifact(threadId: string, runId: string, artifactPath: string): Promise<unknown>;
+    listRunEvents(threadId: string, runId: string): Promise<HarnessEvent[]>;
+    exportEvaluationBundle(input: RuntimeEvaluationExportInput): Promise<RuntimeEvaluationExport>;
     listAgentSkills(agentId: string, options?: RequirementAssessmentOptions): InventorySkillRecord[];
     getAgent(agentId: string, options?: RequirementAssessmentOptions): InventoryAgentRecord | null;
     describeWorkspaceInventory(options?: RequirementAssessmentOptions): {

package/dist/runtime/harness.js

@@ -475,6 +475,51 @@ export class AgentHarnessRuntime {
             persistence: this.persistence,
         }, approvalId);
     }
+    async listArtifacts(threadId, runId) {
+        return this.persistence.listArtifacts(threadId, runId);
+    }
+    async readArtifact(threadId, runId, artifactPath) {
+        return this.persistence.readArtifact(threadId, runId, artifactPath);
+    }
+    async listRunEvents(threadId, runId) {
+        return this.persistence.listRunEvents(threadId, runId);
+    }
+    async exportEvaluationBundle(input) {
+        const thread = await this.getThread(input.sessionId);
+        const run = await this.getRun(input.requestId);
+        const approvals = await this.listApprovals({ threadId: input.sessionId, runId: input.requestId });
+        const transcript = await this.persistence.listThreadMessages(input.sessionId, 500);
+        const events = await this.persistence.listRunEvents(input.sessionId, input.requestId);
+        const runtimeHealth = await this.getHealth();
+        const artifactsListing = input.includeArtifacts === false
+            ? { items: [] }
+            : await this.persistence.listArtifacts(input.sessionId, input.requestId);
+        const artifacts = await Promise.all(artifactsListing.items.map(async (artifact) => ({
+            ...artifact,
+            ...(input.includeArtifactContents === true
+                ? { content: await this.persistence.readArtifact(input.sessionId, input.requestId, artifact.path) }
+                : {}),
+        })));
+        return {
+            session: thread ? toSessionRecord(thread) : null,
+            request: run ? toRequestRecord(run) : null,
+            approvals,
+            transcript,
+            events,
+            artifacts,
+            runtimeHealth,
+            ...(typeof input.expectedOutput === "string" && input.expectedOutput.trim().length > 0
+                ? { expectedOutput: input.expectedOutput.trim() }
+                : {}),
+            rubric: Array.isArray(input.rubric)
+                ? input.rubric.filter((item) => typeof item === "string" && item.trim().length > 0).map((item) => item.trim())
+                : [],
+            tags: Array.isArray(input.tags)
+                ? input.tags.filter((item) => typeof item === "string" && item.trim().length > 0).map((item) => item.trim())
+                : [],
+            ...(input.metadata ? { metadata: { ...input.metadata } } : {}),
+        };
+    }
     listAgentSkills(agentId, options = {}) {
         return listWorkspaceAgentSkills(this.workspace, agentId, {
             assessRequirements: isInventoryEnabled(this.workspace),
@@ -1393,3 +1438,40 @@ export class AgentHarnessRuntime {
         }, thread, nowMs);
     }
 }
+function toRequestSummary(summary) {
+    return {
+        requestId: summary.runId,
+        sessionId: summary.threadId,
+        agentId: summary.agentId,
+        executionMode: summary.executionMode,
+        adapterKind: summary.adapterKind,
+        createdAt: summary.createdAt,
+        updatedAt: summary.updatedAt,
+        state: summary.state,
+        checkpointRef: summary.checkpointRef,
+        resumable: summary.resumable,
+        startedAt: summary.startedAt,
+        endedAt: summary.endedAt,
+        lastActivityAt: summary.lastActivityAt,
+        currentAgentId: summary.currentAgentId,
+        delegationChain: summary.delegationChain,
+        runtimeSnapshot: summary.runtimeSnapshot,
+    };
+}
+function toSessionRecord(record) {
+    return {
+        sessionId: record.threadId,
+        entryAgentId: record.entryAgentId,
+        currentAgentId: record.currentAgentId,
+        currentState: record.currentState,
+        latestRequestId: record.latestRunId,
+        createdAt: record.createdAt,
+        updatedAt: record.updatedAt,
+        messages: record.messages,
+        requests: record.runs.map(toRequestSummary),
+        pendingDecision: record.pendingDecision,
+    };
+}
+function toRequestRecord(record) {
+    return toRequestSummary(record);
+}

package/dist/workspace/agent-binding-compiler.js

@@ -337,6 +337,12 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
     const store = resolveStoreConfig(agent, refs);
     const checkpointer = resolveCheckpointerConfig(agent, refs);
     const runtimeMemory = resolveRuntimeMemoryConfig(agent, refs);
+    const runtimeFilesystemDefaults = agent.executionMode === "langchain-v1"
+        ? asObject(runtimeDefaults?.filesystem)
+        : undefined;
+    const compiledFilesystemConfig = agent.executionMode === "langchain-v1"
+        ? mergeConfigObjects(runtimeFilesystemDefaults, getAgentExecutionObject(agent, "filesystem", { executionMode: "langchain-v1" }))
+        : undefined;
     const runRoot = typeof agent.runRoot === "string" && agent.runRoot.trim().length > 0
         ? path.resolve(workspaceRoot, agent.runRoot)
         : typeof runtimeDefaults?.runRoot === "string" && runtimeDefaults.runRoot.trim().length > 0
@@ -362,7 +368,7 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
                     langchain: {
                         passthrough,
                         interruptOn: resolveInterruptOn(agent),
-                        filesystem: getAgentExecutionObject(agent, "filesystem", { executionMode: "langchain-v1" }),
+                        filesystem: compiledFilesystemConfig,
                         subagents: compileSubagents(agent, agents, workspaceRoot, models, tools, compiledAgentSkills, compiledAgentModel),
                         memory: compiledAgentMemory,
                         skills: compiledAgentSkills,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.156",
+  "version": "0.0.157",
   "description": "Workspace runtime for multi-agent applications",
   "type": "module",
   "packageManager": "npm@10.9.2",
@@ -28,6 +28,11 @@
       "import": "./dist/index.js",
       "default": "./dist/index.js"
     },
+    "./acp": {
+      "types": "./dist/acp.d.ts",
+      "import": "./dist/acp.js",
+      "default": "./dist/acp.js"
+    },
     "./tools": {
       "types": "./dist/tools.d.ts",
       "import": "./dist/tools.js",