@botbotgo/agent-harness 0.0.98 → 0.0.100

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

@@ -42,17 +42,11 @@ export function normalizeRunPriority(priority) {
     return Math.trunc(priority);
 }
 export function resolveRunListeners(options) {
-    const runtimeListeners = "runtimeListeners" in options ? options.runtimeListeners : undefined;
-    const frontendListeners = "frontendListeners" in options ? options.frontendListeners : undefined;
     const listeners = options.listeners;
-    if (!listeners && !runtimeListeners && !frontendListeners) {
+    if (!listeners) {
         return undefined;
     }
-    return {
-        ...(runtimeListeners ?? {}),
-        ...(frontendListeners ?? {}),
-        ...(listeners ?? {}),
-    };
+    return listeners;
 }
 export function mergeRunResultOutput(result, streamedOutput) {
     return {

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

@@ -1,7 +1,5 @@
-import { type MessageContent, type ThreadSummary, type TranscriptMessage, type WorkspaceBundle } from "../../../contracts/types.js";
-export declare function heuristicHostRoute(workspace: WorkspaceBundle, input: MessageContent): string;
+import { type MessageContent, type ThreadSummary, type WorkspaceBundle } from "../../../contracts/types.js";
 export declare function getDefaultHostAgentId(workspace: WorkspaceBundle, preferredHostAgentId: string): string;
-export declare function buildRoutingInput(input: MessageContent, history?: TranscriptMessage[]): string;
 export declare function resolveSelectedAgentId(options: {
     workspace: WorkspaceBundle;
     input: MessageContent;

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

@@ -1,35 +1,12 @@
 import { AUTO_AGENT_ID } from "../../../contracts/types.js";
-import { extractMessageText } from "../../../utils/message-content.js";
-import { heuristicRoute, inferRoutingBindings } from "../../support/harness-support.js";
+import { inferRoutingBindings } from "../../support/harness-support.js";
 import { isRuntimeEntryBinding } from "../../support/runtime-entry.js";
-export function heuristicHostRoute(workspace, input) {
-    const { primaryBinding, secondaryBinding } = inferRoutingBindings(workspace);
-    return heuristicRoute(extractMessageText(input), primaryBinding, secondaryBinding);
-}
 export function getDefaultHostAgentId(workspace, preferredHostAgentId) {
     const preferredBinding = workspace.bindings.get(preferredHostAgentId);
     if (preferredBinding && isRuntimeEntryBinding(preferredBinding)) {
         return preferredBinding.agent.id;
     }
-    return heuristicHostRoute(workspace, "");
-}
-export function buildRoutingInput(input, history = []) {
-    const inputText = extractMessageText(input);
-    const priorHistory = history.filter((message) => extractMessageText(message.content).trim());
-    if (priorHistory.length === 0) {
-        return inputText;
-    }
-    const recentTurns = priorHistory.slice(-6).map((message) => {
-        const role = message.role === "assistant" ? "assistant" : "user";
-        const compact = extractMessageText(message.content).replace(/\s+/g, " ").trim();
-        return `${role}: ${compact.slice(0, 240)}`;
-    });
-    return [
-        "Recent conversation context:",
-        ...recentTurns,
-        "",
-        `Current user request: ${inputText}`,
-    ].join("\n");
+    return inferRoutingBindings(workspace).primaryBinding?.agent.id ?? "agent";
 }
 export async function resolveSelectedAgentId(options) {
     const { workspace, input, requestedAgentId, threadId, preferredHostAgentId, getThreadSummary } = options;

package/dist/runtime/harness/run/run-lifecycle.d.ts

@@ -13,22 +13,11 @@ type LifecycleRuntime<TBinding> = {
         approval: InternalApprovalRecord;
         event: HarnessEvent;
     }>;
-    synthesizeFinalResult: (binding: TBinding, input: MessageContent, actual: RunResult) => Promise<{
-        output: string;
-        finalMessageText?: string;
-        modelId: string;
-    } | null | undefined>;
-    reviewRunResult: (binding: TBinding, input: MessageContent, actual: RunResult) => Promise<{
-        modelId: string;
-        assessment: string;
-    } | null | undefined>;
 };
 export declare function appendAssistantMessage(persistence: Pick<RuntimePersistence, "appendThreadMessage">, threadId: string, runId: string, content?: string): Promise<void>;
 export declare function checkpointRefForState(threadId: string, runId: string, state: RunResult["state"]): string | null;
 export declare function expirePendingApprovals(runtime: Pick<LifecycleRuntime<never>, "persistence" | "emit">, threadId: string, runId: string): Promise<void>;
 export declare function finalizeCancelledRun(runtime: Pick<LifecycleRuntime<never>, "persistence" | "emit" | "setRunStateAndEmit">, threadId: string, runId: string, previousState: RunResult["state"] | null, reason?: string): Promise<RunResult>;
-export declare function synthesizeCompletedRun<TBinding>(runtime: Pick<LifecycleRuntime<TBinding>, "synthesizeFinalResult">, binding: TBinding, input: MessageContent, actual: RunResult): Promise<RunResult>;
-export declare function reviewCompletedRun<TBinding>(runtime: Pick<LifecycleRuntime<TBinding>, "reviewRunResult" | "emit">, binding: TBinding, threadId: string, runId: string, input: MessageContent, actual: RunResult): Promise<void>;
 export declare function finalizeContinuedRun<TBinding>(runtime: LifecycleRuntime<TBinding>, binding: TBinding, threadId: string, runId: string, input: MessageContent, actual: RunResult, options: {
     previousState: RunResult["state"] | null;
     stateSequence: number;

package/dist/runtime/harness/run/run-lifecycle.js

@@ -45,65 +45,22 @@ export async function finalizeCancelledRun(runtime, threadId, runId, previousSta
         output: reason ? `cancelled: ${reason}` : "cancelled",
     };
 }
-export async function synthesizeCompletedRun(runtime, binding, input, actual) {
-    try {
-        const synthesized = await runtime.synthesizeFinalResult(binding, input, actual);
-        if (!synthesized) {
-            return actual;
-        }
-        return {
-            ...actual,
-            output: synthesized.output,
-            finalMessageText: synthesized.finalMessageText,
-            metadata: {
-                ...(typeof actual.metadata === "object" && actual.metadata ? actual.metadata : {}),
-                finalSynthesis: {
-                    modelId: synthesized.modelId,
-                },
-            },
-        };
-    }
-    catch {
-        return actual;
-    }
-}
-export async function reviewCompletedRun(runtime, binding, threadId, runId, input, actual) {
-    try {
-        const review = await runtime.reviewRunResult(binding, input, actual);
-        if (!review) {
-            return;
-        }
-        await runtime.emit(threadId, runId, 7, "run.reviewed", {
-            modelId: review.modelId,
-            assessment: review.assessment,
-        });
-    }
-    catch {
-        // Review is advisory; do not fail the completed run if the review pass fails.
-    }
-}
 export async function finalizeContinuedRun(runtime, binding, threadId, runId, input, actual, options) {
     let approval;
-    const finalizedActual = actual.state === "completed"
-        ? await synthesizeCompletedRun(runtime, binding, input, actual)
-        : actual;
-    await appendAssistantMessage(runtime.persistence, threadId, runId, finalizedActual.output);
+    await appendAssistantMessage(runtime.persistence, threadId, runId, actual.output);
     const checkpointRef = checkpointRefForState(threadId, runId, actual.state);
-    await runtime.setRunStateAndEmit(threadId, runId, options.stateSequence, finalizedActual.state, {
+    await runtime.setRunStateAndEmit(threadId, runId, options.stateSequence, actual.state, {
         previousState: options.previousState,
         checkpointRef,
     });
-    if (finalizedActual.state === "waiting_for_approval" && options.approvalSequence) {
-        approval = (await runtime.requestApprovalAndEmit(threadId, runId, input, finalizedActual.interruptContent, checkpointRef, options.approvalSequence)).approval;
-    }
-    if (finalizedActual.state === "completed") {
-        await reviewCompletedRun(runtime, binding, threadId, runId, input, finalizedActual);
+    if (actual.state === "waiting_for_approval" && options.approvalSequence) {
+        approval = (await runtime.requestApprovalAndEmit(threadId, runId, input, actual.interruptContent, checkpointRef, options.approvalSequence)).approval;
     }
     return {
-        ...finalizedActual,
+        ...actual,
         threadId,
         runId,
-        approvalId: approval?.approvalId ?? finalizedActual.approvalId,
-        pendingActionId: approval?.pendingActionId ?? finalizedActual.pendingActionId,
+        approvalId: approval?.approvalId ?? actual.approvalId,
+        pendingActionId: approval?.pendingActionId ?? actual.pendingActionId,
     };
 }

package/dist/runtime/harness/runtime-defaults.d.ts

@@ -0,0 +1,4 @@
+import type { RuntimeHealthSnapshot, WorkspaceBundle } from "../../contracts/types.js";
+export declare function isThreadMemorySyncEnabled(workspace: WorkspaceBundle): boolean;
+export declare function isInventoryEnabled(workspace: WorkspaceBundle): boolean;
+export declare function createDefaultHealthSnapshot(activeRunSlots: number, pendingRunSlots: number): RuntimeHealthSnapshot;

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

@@ -0,0 +1,39 @@
+export function isThreadMemorySyncEnabled(workspace) {
+    const runtimeMemory = workspace.bindings.values().next().value?.harnessRuntime.runtimeMemory;
+    const syncConfig = typeof runtimeMemory?.threadMemorySync === "object" && runtimeMemory.threadMemorySync
+        ? runtimeMemory.threadMemorySync
+        : undefined;
+    return runtimeMemory?.enabled === true && syncConfig?.enabled === true;
+}
+export function isInventoryEnabled(workspace) {
+    const runtime = workspace.refs.get("runtime/default");
+    const value = runtime && "value" in runtime && typeof runtime.value === "object" && runtime.value
+        ? runtime.value
+        : undefined;
+    const inventory = typeof value?.inventory === "object" && value.inventory
+        ? value.inventory
+        : undefined;
+    return inventory?.enabled === true;
+}
+export function createDefaultHealthSnapshot(activeRunSlots, pendingRunSlots) {
+    const updatedAt = new Date().toISOString();
+    const healthy = { status: "healthy", updatedAt, reason: "health monitor disabled" };
+    return {
+        status: "healthy",
+        updatedAt,
+        checks: {
+            runtime: healthy,
+            llm: healthy,
+            persistence: healthy,
+            capacity: healthy,
+            workload: healthy,
+        },
+        symptoms: [],
+        stats: {
+            activeRunSlots,
+            pendingRunSlots,
+            pendingApprovals: 0,
+            stuckRuns: 0,
+        },
+    };
+}

package/dist/runtime/harness/system/inventory.js

@@ -41,6 +41,7 @@ function mergeRequirementOptions(binding, options = {}) {
     return {
         ...fromBackend,
         ...options,
+        assessRequirements: options.assessRequirements ?? true,
         env: options.env ? { ...(fromBackend.env ?? {}), ...options.env } : fromBackend.env,
         path: options.path ?? fromBackend.path,
     };
@@ -58,7 +59,7 @@ function toSkillRecords(skillPaths, options = {}) {
             allowedTools: metadata.allowedTools,
             userInvocable: metadata.userInvocable,
             openclaw: metadata.openclaw,
-            requirements: assessSkillRequirements(metadata, options),
+            ...(options.assessRequirements === false ? {} : { requirements: assessSkillRequirements(metadata, options) }),
         };
     });
 }

package/dist/runtime/harness/system/skill-requirements.d.ts

@@ -18,6 +18,7 @@ export type SkillRequirementAssessment = {
     openclaw?: OpenClawRequirementAssessment;
 };
 export type RequirementAssessmentOptions = {
+    assessRequirements?: boolean;
     env?: Record<string, string | undefined>;
     path?: string;
     availableBins?: string[];

package/dist/runtime/harness.d.ts

@@ -17,10 +17,8 @@ export declare class AgentHarnessRuntime {
     private readonly vectorStores;
     private readonly defaultStore;
     private readonly runtimeMemoryStore;
-    private readonly routingSystemPrompt?;
     private readonly routingRules;
     private readonly routingDefaultAgentId?;
-    private readonly modelRoutingEnabled;
     private readonly threadMemorySync;
     private readonly unregisterThreadMemorySync;
     private readonly resolvedRuntimeAdapterOptions;
@@ -37,15 +35,16 @@ export declare class AgentHarnessRuntime {
     private runtimeEventSequence;
     private listHostBindings;
     private defaultRunRoot;
-    private heuristicRoute;
     private getDefaultHostAgentId;
-    private buildRoutingInput;
     private resolveSelectedAgentId;
     private resolveStore;
     private resolveStoreFromConfig;
     private resolveEmbeddingModel;
     private resolveVectorStore;
     constructor(workspace: WorkspaceBundle, runtimeAdapterOptions?: RuntimeAdapterOptions);
+    private createHealthMonitor;
+    private recordLlmSuccess;
+    private recordLlmFailure;
     initialize(): Promise<void>;
     subscribe(listener: (event: HarnessEvent) => void): () => void;
     getHealth(): Promise<RuntimeHealthSnapshot>;
@@ -97,8 +96,6 @@ export declare class AgentHarnessRuntime {
     private executeQueuedRun;
     private checkpointRefForState;
     private finalizeContinuedRun;
-    private synthesizeCompletedRun;
-    private reviewCompletedRun;
     private emitOutputDeltaAndCreateItem;
     private createContentBlocksItem;
     private createToolResultKey;
@@ -127,4 +124,3 @@ export declare class AgentHarnessRuntime {
     private reclaimExpiredClaimedRuns;
     private isStaleRunningRun;
 }
-export { AgentHarnessRuntime as AgentHarness };

package/dist/runtime/harness.js

@@ -6,26 +6,28 @@ import { normalizeUpstreamRuntimeEvent } from "./parsing/stream-event-parsing.js
 import { createResourceBackendResolver, createResourceToolResolver } from "../resource/resource.js";
 import { EventBus } from "./harness/events/event-bus.js";
 import { PolicyEngine } from "./harness/system/policy-engine.js";
-import { getConcurrencyConfig, getRecoveryConfig, getRoutingDefaultAgentId, getRoutingRules, getRoutingSystemPrompt, isModelRoutingEnabled, matchRoutingRule, } from "../workspace/support/workspace-ref-utils.js";
+import { getConcurrencyConfig, getRecoveryConfig, getRoutingDefaultAgentId, getRoutingRules, matchRoutingRule, } from "../workspace/support/workspace-ref-utils.js";
 import { createHarnessEvent, inferRoutingBindings, renderRuntimeFailure, renderToolFailure, } from "./support/harness-support.js";
 import { ThreadMemorySync } from "./harness/system/thread-memory-sync.js";
 import { FileBackedStore } from "./harness/system/store.js";
 import { CheckpointMaintenanceLoop, discoverCheckpointMaintenanceTargets, readCheckpointMaintenanceConfig, } from "./checkpoint-maintenance.js";
 import { RuntimeRecordMaintenanceLoop, discoverRuntimeRecordMaintenanceTargets, readRuntimeRecordMaintenanceConfig, } from "./maintenance/runtime-record-maintenance.js";
 import { HealthMonitor } from "./harness/system/health-monitor.js";
+import { readHealthMonitorConfig } from "./harness/system/health-monitor.js";
 import { extractMessageText, normalizeMessageContent } from "../utils/message-content.js";
 import { buildPersistedRunRequest, isTerminalRunState, normalizeInvocationEnvelope, normalizeRunPriority, resolveRunListeners, toPublicApprovalRecord, } from "./harness/run/helpers.js";
 import { emitHarnessEvent, emitRunCreatedEvent, emitSyntheticFallbackEvent, persistApproval, requestApprovalAndEmitEvent, setRunStateAndEmitEvent, } from "./harness/events/events.js";
-import { appendAssistantMessage as appendLifecycleAssistantMessage, checkpointRefForState as getCheckpointRefForRunState, expirePendingApprovals as expireLifecyclePendingApprovals, finalizeCancelledRun as finalizeLifecycleCancelledRun, finalizeContinuedRun as finalizeLifecycleContinuedRun, reviewCompletedRun as reviewLifecycleCompletedRun, synthesizeCompletedRun as synthesizeLifecycleCompletedRun, } from "./harness/run/run-lifecycle.js";
+import { appendAssistantMessage as appendLifecycleAssistantMessage, checkpointRefForState as getCheckpointRefForRunState, expirePendingApprovals as expireLifecyclePendingApprovals, finalizeCancelledRun as finalizeLifecycleCancelledRun, finalizeContinuedRun as finalizeLifecycleContinuedRun, } from "./harness/run/run-lifecycle.js";
 import { createContentBlocksItem as createStreamingContentBlocksItem, createToolResultKey as createStreamingToolResultKey, dispatchRunListeners as dispatchStreamingRunListeners, emitOutputDeltaAndCreateItem as emitStreamingOutputDeltaAndCreateItem, } from "./harness/events/streaming.js";
 import { buildResumePayload as buildHarnessResumePayload, resolveApprovalRecord as resolveHarnessApprovalRecord, } from "./harness/run/resume.js";
 import { dropPendingRunSlot, enqueuePendingRunSlot, shiftNextPendingRunSlot } from "./harness/run/run-queue.js";
-import { buildRoutingInput, getDefaultHostAgentId, heuristicHostRoute, resolveSelectedAgentId } from "./harness/run/routing.js";
+import { getDefaultHostAgentId, resolveSelectedAgentId } from "./harness/run/routing.js";
 import { resolveCheckpointer, resolveEmbeddingModel, resolveStore, resolveStoreFromConfig, resolveVectorStore, } from "./harness/run/resources.js";
 import { createToolMcpServerFromTools, serveToolsOverStdioFromHarness } from "../mcp.js";
 import { getBindingAdapterKind, getBindingPrimaryTools, getBindingStoreConfig } from "./support/compiled-binding.js";
 import { isRuntimeEntryBinding } from "./support/runtime-entry.js";
 import { describeWorkspaceInventory, listAgentSkills as listWorkspaceAgentSkills, } from "./harness/system/inventory.js";
+import { createDefaultHealthSnapshot, isInventoryEnabled, isThreadMemorySyncEnabled, } from "./harness/runtime-defaults.js";
 export class AgentHarnessRuntime {
     workspace;
     runtimeAdapterOptions;
@@ -47,10 +49,8 @@ export class AgentHarnessRuntime {
     vectorStores = new Map();
     defaultStore;
     runtimeMemoryStore;
-    routingSystemPrompt;
     routingRules;
     routingDefaultAgentId;
-    modelRoutingEnabled;
     threadMemorySync;
     unregisterThreadMemorySync;
     resolvedRuntimeAdapterOptions;
@@ -72,15 +72,8 @@ export class AgentHarnessRuntime {
         return (this.listHostBindings()[0]?.harnessRuntime.runRoot ??
             `${this.workspace.workspaceRoot}/run-data`);
     }
-    heuristicRoute(input) {
-        return heuristicHostRoute(this.workspace, input);
-    }
     getDefaultHostAgentId() {
-        return getDefaultHostAgentId(this.workspace, AgentHarnessRuntime.DEFAULT_HOST_AGENT_ID);
-    }
-    async buildRoutingInput(input, threadId) {
-        const history = threadId ? await this.persistence.listThreadMessages(threadId) : [];
-        return buildRoutingInput(input, history);
+        return getDefaultHostAgentId(this.workspace, this.routingDefaultAgentId ?? AgentHarnessRuntime.DEFAULT_HOST_AGENT_ID);
     }
     async resolveSelectedAgentId(input, requestedAgentId, threadId) {
         return resolveSelectedAgentId({
@@ -88,7 +81,7 @@ export class AgentHarnessRuntime {
             input,
             requestedAgentId,
             threadId,
-            preferredHostAgentId: AgentHarnessRuntime.DEFAULT_HOST_AGENT_ID,
+            preferredHostAgentId: this.routingDefaultAgentId ?? AgentHarnessRuntime.DEFAULT_HOST_AGENT_ID,
             getThreadSummary: (currentThreadId) => this.getSession(currentThreadId),
         });
     }
@@ -132,12 +125,16 @@ export class AgentHarnessRuntime {
                 ((binding) => createResourceBackendResolver(workspace)(binding)),
         };
         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.runtimeMemoryStore);
-        this.unregisterThreadMemorySync = this.eventBus.registerProjection(this.threadMemorySync);
+        if (isThreadMemorySyncEnabled(workspace)) {
+            this.threadMemorySync = new ThreadMemorySync(this.persistence, this.runtimeMemoryStore);
+            this.unregisterThreadMemorySync = this.eventBus.registerProjection(this.threadMemorySync);
+        }
+        else {
+            this.threadMemorySync = null;
+            this.unregisterThreadMemorySync = () => { };
+        }
         const checkpointMaintenanceConfig = readCheckpointMaintenanceConfig(workspace);
         this.checkpointMaintenance = checkpointMaintenanceConfig
             ? new CheckpointMaintenanceLoop(discoverCheckpointMaintenanceTargets(workspace), checkpointMaintenanceConfig)
@@ -148,8 +145,12 @@ export class AgentHarnessRuntime {
             : null;
         this.recoveryConfig = getRecoveryConfig(workspace.refs);
         this.concurrencyConfig = getConcurrencyConfig(workspace.refs);
-        this.healthMonitor = new HealthMonitor({
-            workspace,
+        const healthConfig = readHealthMonitorConfig(workspace);
+        this.healthMonitor = healthConfig.enabled ? this.createHealthMonitor() : null;
+    }
+    createHealthMonitor() {
+        return new HealthMonitor({
+            workspace: this.workspace,
             persistence: this.persistence,
             getActiveRunSlots: () => this.activeRunSlots,
             getPendingRunSlots: () => this.pendingRunSlots.length,
@@ -160,18 +161,27 @@ export class AgentHarnessRuntime {
             },
         });
     }
+    recordLlmSuccess(startedAt) {
+        this.healthMonitor?.recordLlmSuccess(Date.now() - startedAt);
+    }
+    recordLlmFailure(startedAt) {
+        this.healthMonitor?.recordLlmFailure(Date.now() - startedAt);
+    }
     async initialize() {
         await this.persistence.initialize();
         await this.checkpointMaintenance?.start();
         await this.runtimeRecordMaintenance?.start();
-        await this.healthMonitor.start();
+        await this.healthMonitor?.start();
         await this.recoverStartupRuns();
     }
     subscribe(listener) {
         return this.eventBus.subscribe(listener);
     }
     async getHealth() {
-        return this.healthMonitor.getSnapshot();
+        if (this.healthMonitor) {
+            return this.healthMonitor.getSnapshot();
+        }
+        return createDefaultHealthSnapshot(this.activeRunSlots, this.pendingRunSlots.length);
     }
     getBinding(agentId) {
         return this.workspace.bindings.get(agentId);
@@ -256,10 +266,16 @@ export class AgentHarnessRuntime {
         return approval ? toPublicApprovalRecord(approval) : null;
     }
     listAgentSkills(agentId, options = {}) {
-        return listWorkspaceAgentSkills(this.workspace, agentId, options);
+        return listWorkspaceAgentSkills(this.workspace, agentId, {
+            assessRequirements: isInventoryEnabled(this.workspace),
+            ...options,
+        });
     }
     describeWorkspaceInventory(options = {}) {
-        return describeWorkspaceInventory(this.workspace, options);
+        return describeWorkspaceInventory(this.workspace, {
+            assessRequirements: isInventoryEnabled(this.workspace),
+            ...options,
+        });
     }
     async deleteThreadCheckpoints(threadId) {
         const resolver = this.resolvedRuntimeAdapterOptions.checkpointerResolver;
@@ -311,10 +327,7 @@ export class AgentHarnessRuntime {
         return serveToolsOverStdioFromHarness(tools, options);
     }
     async routeAgent(input, options = {}) {
-        const routingHistory = options.threadId ? await this.persistence.listThreadMessages(options.threadId) : [];
-        const routingInput = buildRoutingInput(input, routingHistory);
         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);
@@ -322,25 +335,13 @@ export class AgentHarnessRuntime {
                 return configuredBinding.agent.id;
             }
         }
-        if (!this.modelRoutingEnabled) {
-            const defaultBinding = this.routingDefaultAgentId
-                ? this.workspace.bindings.get(this.routingDefaultAgentId)
-                : primaryBinding;
-            if (defaultBinding && isRuntimeEntryBinding(defaultBinding)) {
-                return defaultBinding.agent.id;
-            }
-        }
-        if (!primaryBinding || !secondaryBinding) {
-            return heuristicHostRoute(this.workspace, rawInput);
-        }
-        try {
-            return await this.runtimeAdapter.route(routingInput, primaryBinding, secondaryBinding, {
-                systemPrompt: this.routingSystemPrompt,
-            });
-        }
-        catch {
-            return heuristicHostRoute(this.workspace, rawInput);
+        const defaultBinding = this.routingDefaultAgentId
+            ? this.workspace.bindings.get(this.routingDefaultAgentId)
+            : undefined;
+        if (defaultBinding && isRuntimeEntryBinding(defaultBinding)) {
+            return defaultBinding.agent.id;
         }
+        return this.getDefaultHostAgentId();
     }
     async emit(threadId, runId, sequence, eventType, payload, source = "runtime") {
         return emitHarnessEvent({
@@ -443,11 +444,11 @@ export class AgentHarnessRuntime {
         const startedAt = Date.now();
         try {
             const result = await this.runtimeAdapter.invoke(binding, input, threadId, runId, resumePayload, history, options);
-            this.healthMonitor.recordLlmSuccess(Date.now() - startedAt);
+            this.recordLlmSuccess(startedAt);
             return result;
         }
         catch (error) {
-            this.healthMonitor.recordLlmFailure(Date.now() - startedAt);
+            this.recordLlmFailure(startedAt);
             throw error;
         }
     }
@@ -532,21 +533,8 @@ export class AgentHarnessRuntime {
             emit: (currentThreadId, currentRunId, sequence, eventType, payload, source) => this.emit(currentThreadId, currentRunId, sequence, eventType, payload, source),
             setRunStateAndEmit: (currentThreadId, currentRunId, sequence, state, lifecycleOptions) => this.setRunStateAndEmit(currentThreadId, currentRunId, sequence, state, lifecycleOptions),
             requestApprovalAndEmit: (currentThreadId, currentRunId, lifecycleInput, interruptContent, checkpointRef, sequence) => this.requestApprovalAndEmit(currentThreadId, currentRunId, lifecycleInput, interruptContent, checkpointRef, sequence),
-            synthesizeFinalResult: (currentBinding, lifecycleInput, lifecycleActual) => this.runtimeAdapter.synthesizeFinalResult(currentBinding, lifecycleInput, lifecycleActual),
-            reviewRunResult: (currentBinding, lifecycleInput, lifecycleActual) => this.runtimeAdapter.reviewRunResult(currentBinding, lifecycleInput, lifecycleActual),
         }, binding, threadId, runId, input, actual, options);
     }
-    async synthesizeCompletedRun(binding, input, actual) {
-        return synthesizeLifecycleCompletedRun({
-            synthesizeFinalResult: (currentBinding, lifecycleInput, lifecycleActual) => this.runtimeAdapter.synthesizeFinalResult(currentBinding, lifecycleInput, lifecycleActual),
-        }, binding, input, actual);
-    }
-    async reviewCompletedRun(binding, threadId, runId, input, actual) {
-        return reviewLifecycleCompletedRun({
-            reviewRunResult: (currentBinding, lifecycleInput, lifecycleActual) => this.runtimeAdapter.reviewRunResult(currentBinding, lifecycleInput, lifecycleActual),
-            emit: (currentThreadId, currentRunId, sequence, eventType, payload, source) => this.emit(currentThreadId, currentRunId, sequence, eventType, payload, source),
-        }, binding, threadId, runId, input, actual);
-    }
     async emitOutputDeltaAndCreateItem(threadId, runId, agentId, content) {
         return emitStreamingOutputDeltaAndCreateItem((currentThreadId, currentRunId, sequence, eventType, payload) => this.emit(currentThreadId, currentRunId, sequence, eventType, payload), threadId, runId, agentId, content);
     }
@@ -793,7 +781,7 @@ export class AgentHarnessRuntime {
             input: options.input,
             requestedAgentId: options.agentId,
             threadId: options.threadId,
-            preferredHostAgentId: AgentHarnessRuntime.DEFAULT_HOST_AGENT_ID,
+            preferredHostAgentId: this.routingDefaultAgentId ?? AgentHarnessRuntime.DEFAULT_HOST_AGENT_ID,
             getThreadSummary: (threadId) => this.getSession(threadId),
         });
         const binding = this.workspace.bindings.get(selectedAgentId);
@@ -838,7 +826,7 @@ export class AgentHarnessRuntime {
             input: options.input,
             requestedAgentId: options.agentId,
             threadId: options.threadId,
-            preferredHostAgentId: AgentHarnessRuntime.DEFAULT_HOST_AGENT_ID,
+            preferredHostAgentId: this.routingDefaultAgentId ?? AgentHarnessRuntime.DEFAULT_HOST_AGENT_ID,
             getThreadSummary: (threadId) => this.getSession(threadId),
         });
         const binding = this.workspace.bindings.get(selectedAgentId);
@@ -1178,7 +1166,7 @@ export class AgentHarnessRuntime {
             const startedAt = Date.now();
             try {
                 const actual = await this.runtimeAdapter.invoke(binding, "", threadId, runId, resumePayload, priorHistory);
-                this.healthMonitor.recordLlmSuccess(Date.now() - startedAt);
+                this.recordLlmSuccess(startedAt);
                 const cancelledAfterInvoke = await this.getRunCancellation(runId);
                 if (cancelledAfterInvoke.requested) {
                     return this.finalizeCancelledRun(threadId, runId, "resuming", cancelledAfterInvoke.reason);
@@ -1196,7 +1184,7 @@ export class AgentHarnessRuntime {
                 };
             }
             catch (error) {
-                this.healthMonitor.recordLlmFailure(Date.now() - startedAt);
+                this.recordLlmFailure(startedAt);
                 throw error;
             }
         }
@@ -1233,12 +1221,12 @@ export class AgentHarnessRuntime {
         };
     }
     async close() {
-        await this.healthMonitor.stop();
+        await this.healthMonitor?.stop();
         await this.checkpointMaintenance?.stop();
         await this.runtimeRecordMaintenance?.stop();
         this.unregisterThreadMemorySync();
         await Promise.allSettled(Array.from(this.backgroundTasks));
-        await this.threadMemorySync.close();
+        await this.threadMemorySync?.close();
     }
     async stop() {
         await this.close();
@@ -1391,7 +1379,7 @@ export class AgentHarnessRuntime {
             const startedAt = Date.now();
             try {
                 const actual = await this.runtimeAdapter.invoke(binding, "", thread.threadId, thread.latestRunId, recoveryIntent.resumePayload, priorHistory);
-                this.healthMonitor.recordLlmSuccess(Date.now() - startedAt);
+                this.recordLlmSuccess(startedAt);
                 await this.persistence.clearRecoveryIntent(thread.threadId, thread.latestRunId);
                 await this.finalizeContinuedRun(binding, thread.threadId, thread.latestRunId, runInput, actual, {
                     previousState: "resuming",
@@ -1400,7 +1388,7 @@ export class AgentHarnessRuntime {
                 });
             }
             catch (error) {
-                this.healthMonitor.recordLlmFailure(Date.now() - startedAt);
+                this.recordLlmFailure(startedAt);
                 if (recoveryIntent.attempts + 1 >= this.recoveryConfig.maxRecoveryAttempts) {
                     await this.persistence.setRunState(thread.threadId, thread.latestRunId, "failed", recoveryIntent.checkpointRef);
                     await this.persistence.clearRecoveryIntent(thread.threadId, thread.latestRunId);
@@ -1459,4 +1447,3 @@ export class AgentHarnessRuntime {
         return nowMs - heartbeatAtMs >= this.concurrencyConfig.heartbeatTimeoutMs;
     }
 }
-export { AgentHarnessRuntime as AgentHarness };

package/dist/runtime/index.d.ts

@@ -1,15 +1,4 @@
-export { AgentRuntimeAdapter, AGENT_INTERRUPT_SENTINEL_PREFIX } from "./agent-runtime-adapter.js";
 export { EventBus } from "./harness/events/event-bus.js";
 export { createRuntimeEventSink, RuntimeEventSinkImpl } from "./harness/events/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 { AgentHarnessRuntime, AgentHarness } from "./harness.js";
-export { describeWorkspaceInventory, findAgentBinding, listAgentSkills, listAgentTools, listAvailableAgents, listSpecialists, } from "./harness/system/inventory.js";
-export { assessOpenClawRequirements, assessSkillRequirements, } from "./harness/system/skill-requirements.js";
-export * from "./parsing/index.js";
-export { PolicyEngine } from "./harness/system/policy-engine.js";
-export { createInMemoryStore, FileBackedStore } from "./harness/system/store.js";
-export * from "./support/index.js";
-export { ThreadMemorySync } from "./harness/system/thread-memory-sync.js";
+export { AgentHarnessRuntime } from "./harness.js";
 export type { HarnessEventListener, HarnessEventProjection, RuntimeEventSink } from "../contracts/types.js";

package/dist/runtime/index.js

@@ -1,14 +1,3 @@
-export { AgentRuntimeAdapter, AGENT_INTERRUPT_SENTINEL_PREFIX } from "./agent-runtime-adapter.js";
 export { EventBus } from "./harness/events/event-bus.js";
 export { createRuntimeEventSink, RuntimeEventSinkImpl } from "./harness/events/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 { AgentHarnessRuntime, AgentHarness } from "./harness.js";
-export { describeWorkspaceInventory, findAgentBinding, listAgentSkills, listAgentTools, listAvailableAgents, listSpecialists, } from "./harness/system/inventory.js";
-export { assessOpenClawRequirements, assessSkillRequirements, } from "./harness/system/skill-requirements.js";
-export * from "./parsing/index.js";
-export { PolicyEngine } from "./harness/system/policy-engine.js";
-export { createInMemoryStore, FileBackedStore } from "./harness/system/store.js";
-export * from "./support/index.js";
-export { ThreadMemorySync } from "./harness/system/thread-memory-sync.js";
+export { AgentHarnessRuntime } from "./harness.js";

package/dist/runtime/support/compiled-binding.d.ts

@@ -1,8 +1,6 @@
 import type { CompiledAgentBinding, CompiledModel, CompiledTool, DeepAgentParams, LangChainAgentParams, RuntimeModelSlot } from "../../contracts/types.js";
 export declare function getBindingAdapterKind(binding: CompiledAgentBinding): string;
 export declare function getBindingAdapterConfig(binding: CompiledAgentBinding): Record<string, unknown>;
-export declare function getBindingLangGraphWorkflow(binding: CompiledAgentBinding): Record<string, unknown> | undefined;
-export declare function getBindingLangGraphPreset(binding: CompiledAgentBinding): string | undefined;
 export declare function getBindingLangChainParams(binding: CompiledAgentBinding): LangChainAgentParams | undefined;
 export declare function getBindingDeepAgentParams(binding: CompiledAgentBinding): DeepAgentParams | undefined;
 export declare function isLangChainBinding(binding: CompiledAgentBinding): boolean;