@botbotgo/agent-harness 0.0.38 → 0.0.40

package/dist/mcp.js

@@ -7,14 +7,13 @@ import { loadToolModuleDefinition } from "./tool-modules.js";
 function asResolvedTool(value) {
     return typeof value === "object" && value !== null ? value : null;
 }
-async function buildRawShapeForTool(harness, toolId, resolvedTool) {
-    const tool = harness.getWorkspace().tools.get(toolId);
-    if (!tool) {
+async function buildRawShapeForTool(sourceTool, resolvedTool) {
+    if (!sourceTool) {
         return undefined;
     }
-    if (tool.type === "function") {
-        const imported = await import(pathToFileURL(tool.sourcePath).href);
-        const definition = loadToolModuleDefinition(imported, tool.implementationName ?? tool.id);
+    if (sourceTool.type === "function") {
+        const imported = await import(pathToFileURL(sourceTool.sourcePath).href);
+        const definition = loadToolModuleDefinition(imported, sourceTool.implementationName ?? sourceTool.id);
         return typeof definition.schema.shape === "object" && definition.schema.shape !== null
             ? definition.schema.shape
             : undefined;
@@ -84,17 +83,17 @@ function jsonSchemaToZod(schema) {
             return z.any();
     }
 }
-export async function createToolMcpServerFromHarness(harness, options) {
+export async function createToolMcpServerFromTools(tools, options) {
     const server = new McpServer({
         name: options.serverInfo?.name ?? `agent-harness-${options.agentId}`,
         version: options.serverInfo?.version ?? AGENT_HARNESS_VERSION,
     });
     const allowedNames = options.includeToolNames ? new Set(options.includeToolNames) : null;
-    for (const { compiledTool, resolvedTool } of harness.resolveAgentTools(options.agentId)) {
+    for (const { compiledTool, resolvedTool, sourceTool } of tools) {
         if (allowedNames && !allowedNames.has(compiledTool.name)) {
             continue;
         }
-        const rawShape = await buildRawShapeForTool(harness, compiledTool.id, resolvedTool);
+        const rawShape = await buildRawShapeForTool(sourceTool, resolvedTool);
         server.tool(compiledTool.name, compiledTool.description, rawShape ?? {}, async (input) => ({
             content: [
                 {
@@ -106,8 +105,8 @@ export async function createToolMcpServerFromHarness(harness, options) {
     }
     return server;
 }
-export async function serveToolsOverStdioFromHarness(harness, options) {
-    const server = await createToolMcpServerFromHarness(harness, options);
+export async function serveToolsOverStdioFromHarness(tools, options) {
+    const server = await createToolMcpServerFromTools(tools, options);
     await server.connect(new StdioServerTransport());
     return server;
 }

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.37";
+export declare const AGENT_HARNESS_VERSION = "0.0.39";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.37";
+export const AGENT_HARNESS_VERSION = "0.0.39";

package/dist/resource/resource-impl.d.ts

@@ -1,6 +1,6 @@
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import type { RuntimeAdapterOptions, WorkspaceBundle } from "../contracts/types.js";
-export declare function resolveLocalBuiltinsEntry(currentResourceDir: string, resolveInstalledEntry?: () => string | null): string;
+export declare function resolveLocalResourceProviderEntry(currentResourceDir: string, resolveInstalledEntry?: () => string | null): string;
 export type ResourceToolInfo = {
     toolPath: string;
     backendOperation: string;
@@ -46,3 +46,4 @@ export declare const listBuiltinTools: typeof listResourceTools;
 export declare const listBuiltinToolsForSource: typeof listResourceToolsForSource;
 export declare const createBuiltinBackendResolver: typeof createResourceBackendResolver;
 export declare const createBuiltinToolResolver: typeof createResourceToolResolver;
+export declare const resolveLocalBuiltinsEntry: typeof resolveLocalResourceProviderEntry;

package/dist/resource/resource-impl.js

@@ -16,7 +16,13 @@ import { resolveIsolatedResourceModulePath } from "./isolation.js";
 import { ensureExternalResourceSource, ensureExternalSource, isExternalSourceLocator, parseExternalSourceLocator } from "./sources.js";
 const resourceDir = path.dirname(fileURLToPath(import.meta.url));
 const require = createRequire(import.meta.url);
-function installedBuiltinsEntry() {
+function installedResourceProviderEntry() {
+    try {
+        return require.resolve("@botbotgo/agent-harness-resource");
+    }
+    catch {
+        // Fall through to the legacy package name for backward compatibility only.
+    }
     try {
         return require.resolve("@botbotgo/agent-harness-builtin");
     }
@@ -24,12 +30,10 @@ function installedBuiltinsEntry() {
         return null;
     }
 }
-export function resolveLocalBuiltinsEntry(currentResourceDir, resolveInstalledEntry = installedBuiltinsEntry) {
+export function resolveLocalResourceProviderEntry(currentResourceDir, resolveInstalledEntry = installedResourceProviderEntry) {
     const candidates = [
-        path.resolve(currentResourceDir, "../../../builtins/dist/src/index.js"),
-        path.resolve(currentResourceDir, "../../../agent-harness/packages/builtins/dist/src/index.js"),
-        path.resolve(currentResourceDir, "../../../builtins/src/index.ts"),
-        path.resolve(currentResourceDir, "../../../agent-harness/packages/builtins/src/index.ts"),
+        path.resolve(currentResourceDir, "../../../resource-package/dist/src/index.js"),
+        path.resolve(currentResourceDir, "../../../resource-package/src/index.ts"),
         resolveInstalledEntry(),
     ].filter((candidate) => typeof candidate === "string" && candidate.length > 0);
     for (const candidate of candidates) {
@@ -37,9 +41,9 @@ export function resolveLocalBuiltinsEntry(currentResourceDir, resolveInstalledEn
             return candidate;
         }
     }
-    return candidates.at(-1) ?? path.resolve(currentResourceDir, "../../../agent-harness/packages/builtins/dist/src/index.js");
+    return candidates.at(-1) ?? path.resolve(currentResourceDir, "../../../resource-package/dist/src/index.js");
 }
-const builtinsEntry = resolveLocalBuiltinsEntry(resourceDir);
+const resourceProviderEntry = resolveLocalResourceProviderEntry(resourceDir);
 async function loadLocalResource(entry) {
     if (!existsSync(entry)) {
         return null;
@@ -47,7 +51,7 @@ async function loadLocalResource(entry) {
     const imported = await import(pathToFileURL(entry).href);
     return (imported.default ?? imported);
 }
-const localResource = await loadLocalResource(builtinsEntry);
+const localResource = await loadLocalResource(resourceProviderEntry);
 function listProviderTools(provider) {
     const rawTools = provider?.listResourceTools?.() ?? provider?.listBuiltinTools?.() ?? [];
     return rawTools.map((tool) => ({
@@ -509,7 +513,7 @@ export async function listResourceToolsForSource(source, workspaceRoot = process
 }
 export function createResourceBackendResolver(workspace) {
     const localResolver = createProviderBackendResolver(localResource, workspace);
-    const remoteResolvers = (workspace.resourceSources ?? workspace.builtinSources ?? [])
+    const remoteResolvers = (workspace.resourceSources ?? [])
         .map((source) => remoteResourceCache.get(source))
         .filter((provider) => Boolean(provider))
         .map((provider) => createProviderBackendResolver(provider, workspace))
@@ -525,7 +529,7 @@ export function createResourceToolResolver(workspace, options = {}) {
     const functionResolver = createFunctionToolResolver(workspace);
     const mcpResolver = createMcpToolResolver(workspace);
     const localResolver = createProviderToolResolver(localResource, workspace, options);
-    const remoteResolvers = (workspace.resourceSources ?? workspace.builtinSources ?? [])
+    const remoteResolvers = (workspace.resourceSources ?? [])
         .map((source) => remoteResourceCache.get(source))
         .filter((provider) => Boolean(provider))
         .map((provider) => createProviderToolResolver(provider, workspace, options))
@@ -551,3 +555,4 @@ export const listBuiltinTools = listResourceTools;
 export const listBuiltinToolsForSource = listResourceToolsForSource;
 export const createBuiltinBackendResolver = createResourceBackendResolver;
 export const createBuiltinToolResolver = createResourceToolResolver;
+export const resolveLocalBuiltinsEntry = resolveLocalResourceProviderEntry;

package/dist/resource/resource.d.ts

@@ -1 +1 @@
-export { type ResourceToolInfo, ensureResourceSources, defaultResourceSkillsRoot, defaultResourceConfigRoot, listResourceTools, listResourceToolsForSource, createResourceBackendResolver, createResourceToolResolver, ensureBuiltinSources, builtinSkillsRoot, builtinConfigRoot, listBuiltinTools, listBuiltinToolsForSource, createBuiltinBackendResolver, createBuiltinToolResolver, resolveLocalBuiltinsEntry, } from "./resource-impl.js";
+export { type ResourceToolInfo, ensureResourceSources, defaultResourceSkillsRoot, defaultResourceConfigRoot, listResourceTools, listResourceToolsForSource, createResourceBackendResolver, createResourceToolResolver, resolveLocalResourceProviderEntry, } from "./resource-impl.js";

package/dist/resource/resource.js

@@ -1 +1 @@
-export { ensureResourceSources, defaultResourceSkillsRoot, defaultResourceConfigRoot, listResourceTools, listResourceToolsForSource, createResourceBackendResolver, createResourceToolResolver, ensureBuiltinSources, builtinSkillsRoot, builtinConfigRoot, listBuiltinTools, listBuiltinToolsForSource, createBuiltinBackendResolver, createBuiltinToolResolver, resolveLocalBuiltinsEntry, } from "./resource-impl.js";
+export { ensureResourceSources, defaultResourceSkillsRoot, defaultResourceConfigRoot, listResourceTools, listResourceToolsForSource, createResourceBackendResolver, createResourceToolResolver, resolveLocalResourceProviderEntry, } from "./resource-impl.js";

package/dist/runtime/event-bus.d.ts

@@ -1,6 +1,7 @@
-import type { HarnessEvent } from "../contracts/types.js";
-export declare class EventBus {
-    private readonly emitter;
+import type { HarnessEvent, HarnessEventListener, HarnessEventProjection, RuntimeEventSink } from "../contracts/types.js";
+export declare class EventBus implements RuntimeEventSink {
+    private readonly sink;
     publish(event: HarnessEvent): void;
-    subscribe(listener: (event: HarnessEvent) => void): () => void;
+    subscribe(listener: HarnessEventListener): () => void;
+    registerProjection(projection: HarnessEventProjection): () => void;
 }

package/dist/runtime/event-bus.js

@@ -1,15 +1,13 @@
-import { EventEmitter } from "node:events";
-import { getEventSubscribers } from "../extensions.js";
+import { createRuntimeEventSink } from "./event-sink.js";
 export class EventBus {
-    emitter = new EventEmitter();
+    sink = createRuntimeEventSink();
     publish(event) {
-        this.emitter.emit("event", event);
-        for (const subscriber of getEventSubscribers()) {
-            void Promise.resolve(subscriber.onEvent(event));
-        }
+        this.sink.publish(event);
     }
     subscribe(listener) {
-        this.emitter.on("event", listener);
-        return () => this.emitter.off("event", listener);
+        return this.sink.subscribe(listener);
+    }
+    registerProjection(projection) {
+        return this.sink.registerProjection(projection);
     }
 }

package/dist/runtime/event-sink.d.ts

@@ -0,0 +1,9 @@
+import type { HarnessEvent, HarnessEventListener, HarnessEventProjection, RuntimeEventSink } from "../contracts/types.js";
+export declare class RuntimeEventSinkImpl implements RuntimeEventSink {
+    private readonly emitter;
+    private readonly projections;
+    publish(event: HarnessEvent): void;
+    subscribe(listener: HarnessEventListener): () => void;
+    registerProjection(projection: HarnessEventProjection): () => void;
+}
+export declare function createRuntimeEventSink(): RuntimeEventSinkImpl;

package/dist/runtime/event-sink.js

@@ -0,0 +1,35 @@
+import { EventEmitter } from "node:events";
+import { getEventSubscribers } from "../extensions.js";
+function dispatchListener(listener, event) {
+    void Promise.resolve(listener(event));
+}
+function dispatchProjection(projection, event) {
+    if (projection.shouldHandle && !projection.shouldHandle(event)) {
+        return;
+    }
+    void Promise.resolve(projection.handleEvent(event));
+}
+export class RuntimeEventSinkImpl {
+    emitter = new EventEmitter();
+    projections = new Set();
+    publish(event) {
+        this.emitter.emit("event", event);
+        for (const projection of this.projections) {
+            dispatchProjection(projection, event);
+        }
+        for (const subscriber of getEventSubscribers()) {
+            dispatchListener(subscriber.onEvent, event);
+        }
+    }
+    subscribe(listener) {
+        this.emitter.on("event", listener);
+        return () => this.emitter.off("event", listener);
+    }
+    registerProjection(projection) {
+        this.projections.add(projection);
+        return () => this.projections.delete(projection);
+    }
+}
+export function createRuntimeEventSink() {
+    return new RuntimeEventSinkImpl();
+}

package/dist/runtime/harness.d.ts

@@ -1,5 +1,6 @@
-import type { ApprovalRecord, CompiledTool, HarnessEvent, HarnessStreamItem, MessageContent, RunStartOptions, RestartConversationOptions, RuntimeAdapterOptions, ResumeOptions, RunOptions, RunResult, ThreadSummary, ThreadRecord, WorkspaceBundle } from "../contracts/types.js";
-export declare class AgentHarness {
+import type { ApprovalRecord, HarnessEvent, HarnessStreamItem, MessageContent, RunStartOptions, RestartConversationOptions, RuntimeAdapterOptions, ResumeOptions, RunOptions, RunResult, ThreadSummary, ThreadRecord, WorkspaceBundle } from "../contracts/types.js";
+import { type ToolMcpServerOptions } from "../mcp.js";
+export declare class AgentHarnessRuntime {
     private readonly workspace;
     private readonly runtimeAdapterOptions;
     private readonly eventBus;
@@ -12,8 +13,11 @@ export declare class AgentHarness {
     private readonly vectorStores;
     private readonly defaultStore;
     private readonly routingSystemPrompt?;
+    private readonly routingRules;
+    private readonly routingDefaultAgentId?;
+    private readonly modelRoutingEnabled;
     private readonly threadMemorySync;
-    private readonly unsubscribeThreadMemorySync;
+    private readonly unregisterThreadMemorySync;
     private readonly resolvedRuntimeAdapterOptions;
     private readonly checkpointMaintenance;
     private listHostBindings;
@@ -27,19 +31,22 @@ export declare class AgentHarness {
     constructor(workspace: WorkspaceBundle, runtimeAdapterOptions?: RuntimeAdapterOptions);
     initialize(): Promise<void>;
     subscribe(listener: (event: HarnessEvent) => void): () => void;
-    getWorkspace(): WorkspaceBundle;
-    getBinding(agentId: string): WorkspaceBundle["bindings"] extends Map<any, infer T> ? T | undefined : never;
-    listAgentTools(agentId: string): CompiledTool[];
-    resolveAgentTools(agentId: string): Array<{
-        compiledTool: CompiledTool;
-        resolvedTool: unknown;
-    }>;
-    listSessions(filter?: {
+    private getBinding;
+    private listAgentTools;
+    private resolveAgentTools;
+    listThreads(filter?: {
         agentId?: string;
     }): Promise<ThreadSummary[]>;
     private getSession;
     getThread(threadId: string): Promise<ThreadRecord | null>;
-    listPendingApprovals(): Promise<ApprovalRecord[]>;
+    listApprovals(filter?: {
+        status?: ApprovalRecord["status"];
+        threadId?: string;
+        runId?: string;
+    }): Promise<ApprovalRecord[]>;
+    getApproval(approvalId: string): Promise<ApprovalRecord | null>;
+    createToolMcpServer(options: ToolMcpServerOptions): Promise<import("@modelcontextprotocol/sdk/server/mcp.js").McpServer>;
+    serveToolsOverStdio(options: ToolMcpServerOptions): Promise<import("@modelcontextprotocol/sdk/server/mcp.js").McpServer>;
     routeAgent(input: MessageContent, options?: {
         threadId?: string;
     }): Promise<string>;
@@ -65,4 +72,6 @@ export declare class AgentHarness {
         restart: Record<string, string>;
     }>;
     close(): Promise<void>;
+    stop(): Promise<void>;
 }
+export { AgentHarnessRuntime as AgentHarness };

package/dist/runtime/harness.js

@@ -5,8 +5,8 @@ import { AGENT_INTERRUPT_SENTINEL_PREFIX, AgentRuntimeAdapter, RuntimeOperationT
 import { createResourceBackendResolver, createResourceToolResolver } from "../resource/resource.js";
 import { EventBus } from "./event-bus.js";
 import { PolicyEngine } from "./policy-engine.js";
-import { getRoutingSystemPrompt } from "../workspace/support/workspace-ref-utils.js";
-import { createHarnessEvent, createPendingApproval, heuristicRoute, inferRoutingBindings, resolveDeterministicRouteIntent, renderRuntimeFailure, renderToolFailure, requiresResearchRoute, } from "./support/harness-support.js";
+import { getRoutingDefaultAgentId, getRoutingRules, getRoutingSystemPrompt, isModelRoutingEnabled, matchRoutingRule, } from "../workspace/support/workspace-ref-utils.js";
+import { createHarnessEvent, createPendingApproval, heuristicRoute, inferRoutingBindings, renderRuntimeFailure, renderToolFailure, } from "./support/harness-support.js";
 import { createCheckpointerForConfig, createStoreForConfig } from "./support/runtime-factories.js";
 import { resolveCompiledEmbeddingModel, resolveCompiledEmbeddingModelRef } from "./support/embedding-models.js";
 import { resolveCompiledVectorStore, resolveCompiledVectorStoreRef } from "./support/vector-stores.js";
@@ -14,7 +14,8 @@ import { ThreadMemorySync } from "./thread-memory-sync.js";
 import { FileBackedStore } from "./store.js";
 import { CheckpointMaintenanceLoop, discoverCheckpointMaintenanceTargets, readCheckpointMaintenanceConfig, } from "./checkpoint-maintenance.js";
 import { extractMessageText, normalizeMessageContent } from "../utils/message-content.js";
-export class AgentHarness {
+import { createToolMcpServerFromTools, serveToolsOverStdioFromHarness } from "../mcp.js";
+export class AgentHarnessRuntime {
     workspace;
     runtimeAdapterOptions;
     eventBus = new EventBus();
@@ -27,8 +28,11 @@ export class AgentHarness {
     vectorStores = new Map();
     defaultStore;
     routingSystemPrompt;
+    routingRules;
+    routingDefaultAgentId;
+    modelRoutingEnabled;
     threadMemorySync;
-    unsubscribeThreadMemorySync;
+    unregisterThreadMemorySync;
     resolvedRuntimeAdapterOptions;
     checkpointMaintenance;
     listHostBindings() {
@@ -144,10 +148,11 @@ export class AgentHarness {
         };
         this.runtimeAdapter = new AgentRuntimeAdapter(this.resolvedRuntimeAdapterOptions);
         this.routingSystemPrompt = getRoutingSystemPrompt(workspace.refs);
+        this.routingRules = getRoutingRules(workspace.refs);
+        this.routingDefaultAgentId = getRoutingDefaultAgentId(workspace.refs);
+        this.modelRoutingEnabled = isModelRoutingEnabled(workspace.refs);
         this.threadMemorySync = new ThreadMemorySync(this.persistence, this.defaultStore);
-        this.unsubscribeThreadMemorySync = this.eventBus.subscribe((event) => {
-            void this.threadMemorySync.handleEvent(event);
-        });
+        this.unregisterThreadMemorySync = this.eventBus.registerProjection(this.threadMemorySync);
         const checkpointMaintenanceConfig = readCheckpointMaintenanceConfig(workspace);
         this.checkpointMaintenance = checkpointMaintenanceConfig
             ? new CheckpointMaintenanceLoop(discoverCheckpointMaintenanceTargets(workspace), checkpointMaintenanceConfig)
@@ -160,9 +165,6 @@ export class AgentHarness {
     subscribe(listener) {
         return this.eventBus.subscribe(listener);
     }
-    getWorkspace() {
-        return this.workspace;
-    }
     getBinding(agentId) {
         return this.workspace.bindings.get(agentId);
     }
@@ -186,7 +188,7 @@ export class AgentHarness {
             resolvedTool: resolvedTools[index],
         }));
     }
-    async listSessions(filter) {
+    async listThreads(filter) {
         const threadSummaries = await this.persistence.listSessions();
         if (!filter?.agentId) {
             return threadSummaries;
@@ -231,30 +233,63 @@ export class AgentHarness {
                 : undefined,
         };
     }
-    async listPendingApprovals() {
-        return (await this.persistence.listApprovals()).filter((approval) => approval.status === "pending");
+    async listApprovals(filter) {
+        const approvals = filter?.threadId && filter?.runId
+            ? await this.persistence.getRunApprovals(filter.threadId, filter.runId)
+            : await this.persistence.listApprovals();
+        return approvals.filter((approval) => {
+            if (filter?.status && approval.status !== filter.status) {
+                return false;
+            }
+            if (filter?.threadId && approval.threadId !== filter.threadId) {
+                return false;
+            }
+            if (filter?.runId && approval.runId !== filter.runId) {
+                return false;
+            }
+            return true;
+        });
+    }
+    async getApproval(approvalId) {
+        return this.persistence.getApproval(approvalId);
+    }
+    async createToolMcpServer(options) {
+        const tools = this.resolveAgentTools(options.agentId).map(({ compiledTool, resolvedTool }) => ({
+            compiledTool,
+            resolvedTool,
+            sourceTool: this.workspace.tools.get(compiledTool.id),
+        }));
+        return createToolMcpServerFromTools(tools, options);
+    }
+    async serveToolsOverStdio(options) {
+        const tools = this.resolveAgentTools(options.agentId).map(({ compiledTool, resolvedTool }) => ({
+            compiledTool,
+            resolvedTool,
+            sourceTool: this.workspace.tools.get(compiledTool.id),
+        }));
+        return serveToolsOverStdioFromHarness(tools, options);
     }
     async routeAgent(input, options = {}) {
         const routingInput = await this.buildRoutingInput(input, options.threadId);
-        const normalized = extractMessageText(input).trim().toLowerCase();
-        const { primaryBinding, secondaryBinding, researchBinding } = inferRoutingBindings(this.workspace);
-        const deterministicIntent = resolveDeterministicRouteIntent(normalized);
-        if (requiresResearchRoute(normalized)) {
-            const explicitResearchBinding = this.workspace.bindings.get("research-lite") ?? this.workspace.bindings.get("research");
-            const hostResearchBinding = explicitResearchBinding?.harnessRuntime.hostFacing !== false ? explicitResearchBinding : researchBinding;
-            return hostResearchBinding?.agent.id ?? secondaryBinding?.agent.id ?? primaryBinding?.agent.id ?? heuristicRoute(extractMessageText(input), primaryBinding, secondaryBinding);
-        }
-        if (secondaryBinding?.deepAgentParams) {
-            return secondaryBinding.agent.id;
-        }
-        if (deterministicIntent === "primary") {
-            return primaryBinding?.agent.id ?? heuristicRoute(extractMessageText(input), primaryBinding, secondaryBinding);
+        const rawInput = extractMessageText(input);
+        const { primaryBinding, secondaryBinding } = inferRoutingBindings(this.workspace);
+        const configuredRule = this.routingRules.find((rule) => matchRoutingRule(rawInput, rule, options));
+        if (configuredRule) {
+            const configuredBinding = this.workspace.bindings.get(configuredRule.agentId);
+            if (configuredBinding && configuredBinding.harnessRuntime.hostFacing !== false) {
+                return configuredBinding.agent.id;
+            }
         }
-        if (deterministicIntent === "secondary") {
-            return secondaryBinding?.agent.id ?? primaryBinding?.agent.id ?? heuristicRoute(extractMessageText(input), primaryBinding, secondaryBinding);
+        if (!this.modelRoutingEnabled) {
+            const defaultBinding = this.routingDefaultAgentId
+                ? this.workspace.bindings.get(this.routingDefaultAgentId)
+                : primaryBinding;
+            if (defaultBinding && defaultBinding.harnessRuntime.hostFacing !== false) {
+                return defaultBinding.agent.id;
+            }
         }
         if (!primaryBinding || !secondaryBinding) {
-            return heuristicRoute(extractMessageText(input), primaryBinding, secondaryBinding);
+            return heuristicRoute(rawInput, primaryBinding, secondaryBinding);
         }
         try {
             return await this.runtimeAdapter.route(routingInput, primaryBinding, secondaryBinding, {
@@ -262,7 +297,7 @@ export class AgentHarness {
             });
         }
         catch {
-            return heuristicRoute(extractMessageText(input), primaryBinding, secondaryBinding);
+            return heuristicRoute(rawInput, primaryBinding, secondaryBinding);
         }
     }
     async emit(threadId, runId, sequence, eventType, payload, source = "runtime") {
@@ -761,7 +796,11 @@ export class AgentHarness {
     }
     async close() {
         await this.checkpointMaintenance?.stop();
-        this.unsubscribeThreadMemorySync();
+        this.unregisterThreadMemorySync();
         await this.threadMemorySync.close();
     }
+    async stop() {
+        await this.close();
+    }
 }
+export { AgentHarnessRuntime as AgentHarness };

package/dist/runtime/index.d.ts

@@ -1,12 +1,14 @@
 export { AgentRuntimeAdapter, AGENT_INTERRUPT_SENTINEL_PREFIX } from "./agent-runtime-adapter.js";
 export { EventBus } from "./event-bus.js";
+export { createRuntimeEventSink, RuntimeEventSinkImpl } from "./event-sink.js";
 export { FileCheckpointSaver } from "./file-checkpoint-saver.js";
 export { CheckpointMaintenanceLoop, discoverCheckpointMaintenanceTargets, maintainSqliteCheckpoints, readCheckpointMaintenanceConfig, } from "./checkpoint-maintenance.js";
 export { ManagedSqliteSaver } from "./sqlite-maintained-checkpoint-saver.js";
-export { AgentHarness } from "./harness.js";
+export { AgentHarnessRuntime, AgentHarness } from "./harness.js";
 export { describeWorkspaceInventory, findAgentBinding, listAgentSkills, listAgentTools, listAvailableAgents, listSpecialists, } from "./inventory.js";
 export * from "./parsing/index.js";
 export { PolicyEngine } from "./policy-engine.js";
 export { createInMemoryStore, FileBackedStore } from "./store.js";
 export * from "./support/index.js";
 export { ThreadMemorySync } from "./thread-memory-sync.js";
+export type { HarnessEventListener, HarnessEventProjection, RuntimeEventSink } from "../contracts/types.js";

package/dist/runtime/index.js

@@ -1,9 +1,10 @@
 export { AgentRuntimeAdapter, AGENT_INTERRUPT_SENTINEL_PREFIX } from "./agent-runtime-adapter.js";
 export { EventBus } from "./event-bus.js";
+export { createRuntimeEventSink, RuntimeEventSinkImpl } from "./event-sink.js";
 export { FileCheckpointSaver } from "./file-checkpoint-saver.js";
 export { CheckpointMaintenanceLoop, discoverCheckpointMaintenanceTargets, maintainSqliteCheckpoints, readCheckpointMaintenanceConfig, } from "./checkpoint-maintenance.js";
 export { ManagedSqliteSaver } from "./sqlite-maintained-checkpoint-saver.js";
-export { AgentHarness } from "./harness.js";
+export { AgentHarnessRuntime, AgentHarness } from "./harness.js";
 export { describeWorkspaceInventory, findAgentBinding, listAgentSkills, listAgentTools, listAvailableAgents, listSpecialists, } from "./inventory.js";
 export * from "./parsing/index.js";
 export { PolicyEngine } from "./policy-engine.js";

package/dist/runtime/support/harness-support.js

@@ -133,11 +133,18 @@ export function inferRoutingBindings(workspace) {
     const directBinding = hostBindings.find((binding) => binding.agent.id === "direct");
     const langchainHost = hostBindings.find((binding) => binding.agent.executionMode === "langchain-v1" && binding.agent.id !== researchBinding?.agent.id);
     const deepagentHosts = hostBindings.filter((binding) => binding.agent.executionMode === "deepagent");
+    const defaultDeepagentHost = deepagentHosts.find((binding) => binding.agent.id === "orchestra") ??
+        deepagentHosts.find((binding) => (binding.deepAgentParams?.subagents.length ?? 0) > 0) ??
+        deepagentHosts[0];
     const deepagentWithSubagents = deepagentHosts.find((binding) => (binding.deepAgentParams?.subagents.length ?? 0) > 0) ??
         deepagentHosts[0];
-    const primaryBinding = directBinding ?? langchainHost ?? hostBindings[0];
-    const secondaryBinding = deepagentWithSubagents && deepagentWithSubagents.agent.id !== primaryBinding?.agent.id
-        ? deepagentWithSubagents
-        : hostBindings.find((binding) => binding.agent.id !== primaryBinding?.agent.id);
+    const primaryBinding = defaultDeepagentHost ?? directBinding ?? langchainHost ?? hostBindings[0];
+    const secondaryBinding = langchainHost && langchainHost.agent.id !== primaryBinding?.agent.id
+        ? langchainHost
+        : directBinding && directBinding.agent.id !== primaryBinding?.agent.id
+            ? directBinding
+            : deepagentWithSubagents && deepagentWithSubagents.agent.id !== primaryBinding?.agent.id
+                ? deepagentWithSubagents
+                : hostBindings.find((binding) => binding.agent.id !== primaryBinding?.agent.id);
     return { primaryBinding, secondaryBinding, researchBinding, hostBindings };
 }

package/dist/runtime/thread-memory-sync.d.ts

@@ -1,12 +1,14 @@
-import type { HarnessEvent } from "../contracts/types.js";
+import type { HarnessEvent, HarnessEventProjection } from "../contracts/types.js";
 import type { FilePersistence } from "../persistence/file-store.js";
-export declare class ThreadMemorySync {
+export declare class ThreadMemorySync implements HarnessEventProjection {
     private readonly persistence;
     private readonly store?;
     private readonly pending;
+    readonly name = "thread-memory-sync";
     constructor(persistence: FilePersistence, store?: {
         put: (namespace: string[], key: string, value: Record<string, any>) => Promise<void>;
     } | undefined);
+    shouldHandle(event: HarnessEvent): boolean;
     handleEvent(event: HarnessEvent): Promise<void>;
     private syncThread;
     close(): Promise<void>;

package/dist/runtime/thread-memory-sync.js

@@ -42,16 +42,25 @@ function renderOpenApprovalsMarkdown(approvals) {
     }
     return lines.join("\n");
 }
+const THREAD_MEMORY_EVENT_TYPES = new Set([
+    "run.state.changed",
+    "approval.resolved",
+    "approval.requested",
+]);
 export class ThreadMemorySync {
     persistence;
     store;
     pending = new Set();
+    name = "thread-memory-sync";
     constructor(persistence, store) {
         this.persistence = persistence;
         this.store = store;
     }
+    shouldHandle(event) {
+        return THREAD_MEMORY_EVENT_TYPES.has(event.eventType);
+    }
     async handleEvent(event) {
-        if (event.eventType !== "run.state.changed" && event.eventType !== "approval.resolved" && event.eventType !== "approval.requested") {
+        if (!this.shouldHandle(event)) {
             return;
         }
         const task = this.syncThread(event.threadId)

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

@@ -52,9 +52,6 @@ function resolveAgentRuntimeName(agent) {
         return baseName;
     }
     const normalizedSourcePath = agent.sourcePath.split(path.sep).join("/");
-    if (normalizedSourcePath.includes("/packages/builtins/")) {
-        return `builtin.${baseName}`;
-    }
     if (normalizedSourcePath.includes("/packages/framework/")) {
         return `core.${baseName}`;
     }

package/dist/workspace/compile.js

@@ -5,7 +5,7 @@ import { validateAgent, validateTopology } from "./validate.js";
 import { compileBinding } from "./agent-binding-compiler.js";
 import { discoverSubagents, ensureDiscoverySources } from "./support/discovery.js";
 import { collectAgentDiscoverySourceRefs, collectToolSourceRefs } from "./support/source-collectors.js";
-import { resolveRefId } from "./support/workspace-ref-utils.js";
+import { getRoutingDefaultAgentId, getRoutingRules, resolveRefId, } from "./support/workspace-ref-utils.js";
 import { hydrateAgentMcpTools, hydrateResourceAndExternalTools } from "./tool-hydration.js";
 function collectParsedResources(refs) {
     const embeddings = new Map();
@@ -70,6 +70,20 @@ function compileBindings(workspaceRoot, refs, agentsList, models, tools) {
     }
     return bindings;
 }
+function validateRoutingTargets(refs, agentsList) {
+    const hostFacingAgentIds = new Set(agentsList
+        .filter((agent) => !agentsList.some((owner) => owner.subagentRefs.some((ref) => resolveRefId(ref) === agent.id)))
+        .map((agent) => agent.id));
+    const defaultAgentId = getRoutingDefaultAgentId(refs);
+    if (defaultAgentId && !hostFacingAgentIds.has(defaultAgentId)) {
+        throw new Error(`Runtime routing.defaultAgentId references unknown host-facing agent ${defaultAgentId}`);
+    }
+    for (const rule of getRoutingRules(refs)) {
+        if (!hostFacingAgentIds.has(rule.agentId)) {
+            throw new Error(`Runtime routing.rules references unknown host-facing agent ${rule.agentId}`);
+        }
+    }
+}
 export async function loadWorkspace(workspaceRoot, options = {}) {
     const loaded = await loadWorkspaceObjects(workspaceRoot, options);
     loaded.agents = await discoverSubagents(loaded.agents, workspaceRoot);
@@ -84,10 +98,10 @@ export async function loadWorkspace(workspaceRoot, options = {}) {
     await ensureResourceSources(toolSourceRefs, workspaceRoot);
     await hydrateResourceAndExternalTools(tools, toolSourceRefs, workspaceRoot);
     validateWorkspaceResources(embeddings, mcpServers, models, vectorStores, tools, loaded.agents);
+    validateRoutingTargets(loaded.refs, loaded.agents);
     return {
         workspaceRoot,
         resourceSources: [...toolSourceRefs],
-        builtinSources: [...toolSourceRefs],
         refs: loaded.refs,
         embeddings,
         mcpServers,