@botbotgo/agent-harness 0.0.155 → 0.0.157

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;
@@ -195,6 +216,37 @@ export type RecallInput = {
 export type RecallResult = {
     items: MemoryRecord[];
 };
+export type ListMemoriesInput = {
+    scopes?: MemoryScope[];
+    kinds?: MemoryKind[];
+    status?: MemoryRecordStatus[];
+    threadId?: string;
+    agentId?: string;
+    workspaceId?: string;
+    userId?: string;
+    projectId?: string;
+    limit?: number;
+};
+export type ListMemoriesResult = {
+    items: MemoryRecord[];
+};
+export type UpdateMemoryInput = {
+    memoryId: string;
+    content?: string;
+    summary?: string;
+    status?: MemoryRecordStatus;
+    confidence?: number;
+    expiresAt?: string | null;
+    sourceType?: string;
+    sourceRefs?: string[];
+    tags?: string[];
+    observedAt?: string;
+    lastConfirmedAt?: string;
+    provenance?: Record<string, unknown>;
+};
+export type RemoveMemoryInput = {
+    memoryId: string;
+};
 /**
  * Operator-facing projection of tool execution policy already compiled into a binding.
  * This summarizes existing timeout, retry, validation, and retry-safety hints without
@@ -508,6 +560,7 @@ export type SkillPackagingConvention = {
 export type PolicyDecision = {
     allowed: boolean;
     reasons: string[];
+    bundles?: RuntimeGovernanceBundle[];
 };
 export type PolicyEvaluator = {
     kind: string;
@@ -517,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, getSession, listAgentSkills, listApprovals, listRequests, listSessions, memorize, normalizeUserChatInput, recall, resolveApproval, run, serveToolsOverStdio, subscribe, stop, } from "./api.js";
-export type { MemoryDecision, MemoryKind, MemoryRecord, MemoryScope, MemorizeInput, MemorizeResult, NormalizeUserChatInputOptions, RecallInput, RecallResult, 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, getSession, listAgentSkills, listApprovals, listRequests, listSessions, memorize, normalizeUserChatInput, recall, resolveApproval, run, serveToolsOverStdio, subscribe, stop, } 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.154";
+export declare const AGENT_HARNESS_VERSION = "0.0.156";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.154";
+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/system/runtime-memory-records.d.ts

@@ -15,6 +15,9 @@ export declare function renderMemoryRecordsMarkdown(title: string, records: Memo
 export declare function rebuildStructuredMemoryProjections(store: StoreLike, namespace: string[], title: string, scope: MemoryScope, maxEntries: number): Promise<void>;
 export declare function listMemoryRecordsForScopes(store: StoreLike, scopes: MemoryScope[]): Promise<MemoryRecord[]>;
 export declare function getMemoryRecord(store: StoreLike, scope: MemoryScope, recordId: string): Promise<MemoryRecord | null>;
+export declare function findMemoryRecordById(store: StoreLike, recordId: string): Promise<MemoryRecord | null>;
+export declare function updateMemoryRecord(store: StoreLike, record: MemoryRecord, updatedAt: string): Promise<MemoryRecord>;
+export declare function removeMemoryRecord(store: StoreLike, scope: MemoryScope, recordId: string): Promise<MemoryRecord | null>;
 export declare function persistStructuredMemoryRecords(options: PersistMemoryRecordsOptions): Promise<{
     records: MemoryRecord[];
     decisions: MemoryDecision[];

package/dist/runtime/harness/system/runtime-memory-records.js

@@ -34,6 +34,12 @@ function createCanonicalKey(candidate, kind, scope) {
 function buildScopeNamespace(scope) {
     return ["memories", "records", scope];
 }
+function buildCanonicalIndexNamespace(scope) {
+    return ["memories", "indexes", "canonical", scope];
+}
+function buildSourceRefIndexNamespace(scope) {
+    return ["memories", "indexes", "source-ref", scope];
+}
 function normalizeTextForCompare(value) {
     return value.toLowerCase().replace(/\s+/g, " ").trim();
 }
@@ -312,7 +318,7 @@ function evaluateDecision(existing, incoming, recordedAt) {
 async function putRecordWithIndexes(store, record, updatedAt) {
     const canonicalKeyId = createFingerprint(record.canonicalKey);
     await store.put(buildScopeNamespace(record.scope), `${record.id}.json`, record);
-    await store.put(["memories", "indexes", "canonical", record.scope], `${canonicalKeyId}-${record.id}.json`, {
+    await store.put(buildCanonicalIndexNamespace(record.scope), `${canonicalKeyId}-${record.id}.json`, {
         canonicalKey: record.canonicalKey,
         recordId: record.id,
         scope: record.scope,
@@ -321,7 +327,7 @@ async function putRecordWithIndexes(store, record, updatedAt) {
     });
     await Promise.all(record.sourceRefs.map((sourceRef) => {
         const sourceRefId = createFingerprint(sourceRef);
-        return store.put(["memories", "indexes", "source-ref", record.scope], `${sourceRefId}-${record.id}.json`, {
+        return store.put(buildSourceRefIndexNamespace(record.scope), `${sourceRefId}-${record.id}.json`, {
             sourceRef,
             recordId: record.id,
             scope: record.scope,
@@ -384,6 +390,46 @@ export async function getMemoryRecord(store, scope, recordId) {
     const candidate = record;
     return typeof candidate.id === "string" && typeof candidate.content === "string" ? candidate : null;
 }
+export async function findMemoryRecordById(store, recordId) {
+    for (const scope of MEMORY_SCOPES) {
+        const record = await getMemoryRecord(store, scope, recordId);
+        if (record) {
+            return record;
+        }
+    }
+    return null;
+}
+async function deleteRecordIndexes(store, record) {
+    const [canonicalEntries, sourceRefEntries] = await Promise.all([
+        store.search(buildCanonicalIndexNamespace(record.scope)),
+        store.search(buildSourceRefIndexNamespace(record.scope)),
+    ]);
+    await Promise.all([
+        ...canonicalEntries
+            .filter((entry) => entry.value?.recordId === record.id)
+            .map((entry) => store.delete(entry.namespace, entry.key)),
+        ...sourceRefEntries
+            .filter((entry) => entry.value?.recordId === record.id)
+            .map((entry) => store.delete(entry.namespace, entry.key)),
+    ]);
+}
+export async function updateMemoryRecord(store, record, updatedAt) {
+    const existing = await getMemoryRecord(store, record.scope, record.id);
+    if (existing) {
+        await deleteRecordIndexes(store, existing);
+    }
+    await putRecordWithIndexes(store, record, updatedAt);
+    return record;
+}
+export async function removeMemoryRecord(store, scope, recordId) {
+    const existing = await getMemoryRecord(store, scope, recordId);
+    if (!existing) {
+        return null;
+    }
+    await deleteRecordIndexes(store, existing);
+    await store.delete(buildScopeNamespace(scope), `${recordId}.json`);
+    return existing;
+}
 export async function persistStructuredMemoryRecords(options) {
     const existingRecords = await listStoredRecords(options.store);
     const persistedRecords = [];