@botbotgo/agent-harness 0.0.104 → 0.0.106

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.103";
+export declare const AGENT_HARNESS_VERSION = "0.0.105";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.103";
+export const AGENT_HARNESS_VERSION = "0.0.105";

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

@@ -1,10 +1,10 @@
 import { type MessageContent, type ThreadSummary, type WorkspaceBundle } from "../../../contracts/types.js";
-export declare function getDefaultHostAgentId(workspace: WorkspaceBundle, preferredHostAgentId: string): string;
+export declare function getDefaultHostAgentId(workspace: WorkspaceBundle, preferredHostAgentId?: string): string;
 export declare function resolveSelectedAgentId(options: {
     workspace: WorkspaceBundle;
     input: MessageContent;
     requestedAgentId?: string;
     threadId?: string;
-    preferredHostAgentId: string;
+    preferredHostAgentId?: string;
     getThreadSummary: (threadId: string) => Promise<ThreadSummary | null>;
 }): Promise<string>;

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

@@ -1,9 +1,8 @@
 import { AUTO_AGENT_ID } from "../../../contracts/types.js";
 import { inferRoutingBindings } from "../../support/harness-support.js";
-import { isRuntimeEntryBinding } from "../../support/runtime-entry.js";
 export function getDefaultHostAgentId(workspace, preferredHostAgentId) {
-    const preferredBinding = workspace.bindings.get(preferredHostAgentId);
-    if (preferredBinding && isRuntimeEntryBinding(preferredBinding)) {
+    const preferredBinding = preferredHostAgentId ? workspace.bindings.get(preferredHostAgentId) : undefined;
+    if (preferredBinding) {
         return preferredBinding.agent.id;
     }
     return inferRoutingBindings(workspace).primaryBinding?.agent.id ?? "agent";
@@ -14,7 +13,7 @@ export async function resolveSelectedAgentId(options) {
         if (threadId) {
             const thread = await getThreadSummary(threadId);
             const threadBinding = thread ? workspace.bindings.get(thread.agentId) : undefined;
-            if (thread?.agentId && threadBinding && isRuntimeEntryBinding(threadBinding)) {
+            if (thread?.agentId && threadBinding) {
                 return thread.agentId;
             }
         }

package/dist/runtime/harness/system/health-monitor.d.ts

@@ -24,18 +24,6 @@ type HealthMonitorConfig = {
             degradedAbove: number;
             unhealthyAbove: number;
         };
-        checkpointBytes: {
-            degradedAbove: number;
-            unhealthyAbove: number;
-        };
-        runtimeDbBytes: {
-            degradedAbove: number;
-            unhealthyAbove: number;
-        };
-        artifactBytes: {
-            degradedAbove: number;
-            unhealthyAbove: number;
-        };
     };
 };
 type HealthMonitorOptions = {
@@ -51,12 +39,9 @@ export declare function readHealthMonitorConfig(workspace: WorkspaceBundle): Hea
 export declare class HealthMonitor {
     private readonly options;
     private readonly config;
-    private readonly runRoots;
-    private readonly checkpointDbPaths;
     private readonly llmSamples;
     private timer;
     private latestSnapshot;
-    private runtimeEventSequence;
     constructor(options: HealthMonitorOptions);
     recordLlmSuccess(latencyMs: number, nowMs?: number): void;
     recordLlmFailure(latencyMs: number, nowMs?: number): void;
@@ -67,15 +52,7 @@ export declare class HealthMonitor {
     evaluate(nowMs?: number): Promise<RuntimeHealthSnapshot>;
     private llmStats;
     private evaluateLlmCheck;
-    private llmSymptoms;
-    private evaluatePersistenceCheck;
-    private evaluateCapacityCheck;
-    private capacitySymptoms;
     private evaluateWorkloadCheck;
-    private workloadSymptoms;
     private countStuckRuns;
-    private sumRuntimeDbBytes;
-    private sumCheckpointDbBytes;
-    private sumArtifactBytes;
 }
 export {};

package/dist/runtime/harness/system/health-monitor.js

@@ -1,7 +1,4 @@
-import path from "node:path";
-import { readdir, stat } from "node:fs/promises";
 import { getRuntimeDefaults } from "../../../workspace/support/workspace-ref-utils.js";
-import { discoverCheckpointMaintenanceTargets } from "../../maintenance/checkpoint-maintenance.js";
 const DEFAULT_HEALTH_CONFIG = {
     enabled: false,
     evaluateIntervalSeconds: 30,
@@ -25,18 +22,6 @@ const DEFAULT_HEALTH_CONFIG = {
             degradedAbove: 300,
             unhealthyAbove: 900,
         },
-        checkpointBytes: {
-            degradedAbove: 512 * 1024 * 1024,
-            unhealthyAbove: 2 * 1024 * 1024 * 1024,
-        },
-        runtimeDbBytes: {
-            degradedAbove: 256 * 1024 * 1024,
-            unhealthyAbove: 1024 * 1024 * 1024,
-        },
-        artifactBytes: {
-            degradedAbove: 512 * 1024 * 1024,
-            unhealthyAbove: 2 * 1024 * 1024 * 1024,
-        },
     },
 };
 function asObject(value) {
@@ -52,23 +37,18 @@ function maxStatus(left, right) {
     const rank = { healthy: 0, degraded: 1, unhealthy: 2 };
     return rank[left] >= rank[right] ? left : right;
 }
-function compareStatus(left, right) {
-    return left === right;
-}
-function computeP95(values) {
-    if (values.length === 0) {
-        return undefined;
-    }
-    const sorted = [...values].sort((a, b) => a - b);
-    const index = Math.min(sorted.length - 1, Math.max(0, Math.ceil(sorted.length * 0.95) - 1));
-    return sorted[index];
-}
-function isoFromMs(value) {
-    return new Date(value).toISOString();
-}
 function buildCheck(status, updatedAt, reason) {
     return reason ? { status, updatedAt, reason } : { status, updatedAt };
 }
+function createSymptom(code, status, message, timestamp) {
+    return {
+        code,
+        severity: status === "unhealthy" ? "error" : status === "degraded" ? "warn" : "info",
+        message,
+        firstSeenAt: timestamp,
+        lastSeenAt: timestamp,
+    };
+}
 function describeThresholdStatus(value, thresholds) {
     if (value >= thresholds.unhealthyAbove) {
         return "unhealthy";
@@ -78,6 +58,14 @@ function describeThresholdStatus(value, thresholds) {
     }
     return "healthy";
 }
+function computeP95(values) {
+    if (values.length === 0) {
+        return undefined;
+    }
+    const sorted = [...values].sort((a, b) => a - b);
+    const index = Math.min(sorted.length - 1, Math.max(0, Math.ceil(sorted.length * 0.95) - 1));
+    return sorted[index];
+}
 export function readHealthMonitorConfig(workspace) {
     const runtimeDefaults = getRuntimeDefaults(workspace.refs);
     const observability = asObject(runtimeDefaults?.observability);
@@ -87,9 +75,6 @@ export function readHealthMonitorConfig(workspace) {
     const llmP95LatencyMs = asObject(thresholds?.llmP95LatencyMs);
     const pendingApprovals = asObject(thresholds?.pendingApprovals);
     const stuckRunSeconds = asObject(thresholds?.stuckRunSeconds);
-    const checkpointBytes = asObject(thresholds?.checkpointBytes);
-    const runtimeDbBytes = asObject(thresholds?.runtimeDbBytes);
-    const artifactBytes = asObject(thresholds?.artifactBytes);
     return {
         enabled: health?.enabled === true,
         evaluateIntervalSeconds: readPositiveNumber(health?.evaluateIntervalSeconds, DEFAULT_HEALTH_CONFIG.evaluateIntervalSeconds),
@@ -113,112 +98,18 @@ export function readHealthMonitorConfig(workspace) {
                 degradedAbove: readNonNegativeNumber(stuckRunSeconds?.degradedAbove, DEFAULT_HEALTH_CONFIG.thresholds.stuckRunSeconds.degradedAbove),
                 unhealthyAbove: readNonNegativeNumber(stuckRunSeconds?.unhealthyAbove, DEFAULT_HEALTH_CONFIG.thresholds.stuckRunSeconds.unhealthyAbove),
             },
-            checkpointBytes: {
-                degradedAbove: readNonNegativeNumber(checkpointBytes?.degradedAbove, DEFAULT_HEALTH_CONFIG.thresholds.checkpointBytes.degradedAbove),
-                unhealthyAbove: readNonNegativeNumber(checkpointBytes?.unhealthyAbove, DEFAULT_HEALTH_CONFIG.thresholds.checkpointBytes.unhealthyAbove),
-            },
-            runtimeDbBytes: {
-                degradedAbove: readNonNegativeNumber(runtimeDbBytes?.degradedAbove, DEFAULT_HEALTH_CONFIG.thresholds.runtimeDbBytes.degradedAbove),
-                unhealthyAbove: readNonNegativeNumber(runtimeDbBytes?.unhealthyAbove, DEFAULT_HEALTH_CONFIG.thresholds.runtimeDbBytes.unhealthyAbove),
-            },
-            artifactBytes: {
-                degradedAbove: readNonNegativeNumber(artifactBytes?.degradedAbove, DEFAULT_HEALTH_CONFIG.thresholds.artifactBytes.degradedAbove),
-                unhealthyAbove: readNonNegativeNumber(artifactBytes?.unhealthyAbove, DEFAULT_HEALTH_CONFIG.thresholds.artifactBytes.unhealthyAbove),
-            },
         },
     };
 }
-async function safeFileSize(filePath) {
-    try {
-        const stats = await stat(filePath);
-        return stats.size;
-    }
-    catch {
-        return 0;
-    }
-}
-async function directorySize(root) {
-    try {
-        const entries = await readdir(root, { withFileTypes: true });
-        let total = 0;
-        for (const entry of entries) {
-            const fullPath = path.join(root, entry.name);
-            if (entry.isDirectory()) {
-                total += await directorySize(fullPath);
-                continue;
-            }
-            if (entry.isFile()) {
-                total += await safeFileSize(fullPath);
-            }
-        }
-        return total;
-    }
-    catch {
-        return 0;
-    }
-}
-function evaluateMaintenanceStatus(label, status, updatedAt) {
-    if (!status) {
-        return {
-            check: buildCheck("healthy", updatedAt, `${label} disabled`),
-            symptoms: [],
-        };
-    }
-    if (status.consecutiveFailures > 0) {
-        return {
-            check: buildCheck("degraded", updatedAt, `${label} has ${status.consecutiveFailures} consecutive failure(s)`),
-            symptoms: [{
-                    code: `${label}.loop.failure`,
-                    severity: "warn",
-                    message: status.lastError ?? `${label} maintenance loop failed`,
-                    firstSeenAt: status.lastFailedAt ?? updatedAt,
-                    lastSeenAt: status.lastFailedAt ?? updatedAt,
-                }],
-        };
-    }
-    if (status.lastCompletedAt) {
-        return {
-            check: buildCheck("healthy", updatedAt, `${label} completed successfully`),
-            symptoms: [],
-        };
-    }
-    return {
-        check: buildCheck("healthy", updatedAt, `${label} idle`),
-        symptoms: [],
-    };
-}
-function normalizeSeverity(status) {
-    if (status === "unhealthy") {
-        return "error";
-    }
-    if (status === "degraded") {
-        return "warn";
-    }
-    return "info";
-}
-function createSymptom(code, status, message, timestamp) {
-    return {
-        code,
-        severity: normalizeSeverity(status),
-        message,
-        firstSeenAt: timestamp,
-        lastSeenAt: timestamp,
-    };
-}
 export class HealthMonitor {
     options;
     config;
-    runRoots;
-    checkpointDbPaths;
     llmSamples = [];
     timer = null;
     latestSnapshot = null;
-    runtimeEventSequence = 0;
     constructor(options) {
         this.options = options;
         this.config = readHealthMonitorConfig(options.workspace);
-        this.runRoots = Array.from(new Set(Array.from(options.workspace.bindings.values()).map((binding) => binding.harnessRuntime.runRoot)));
-        this.checkpointDbPaths = Array.from(new Set(discoverCheckpointMaintenanceTargets(options.workspace).map((target) => target.dbPath)));
     }
     recordLlmSuccess(latencyMs, nowMs = Date.now()) {
         this.recordLlmSample({ timestampMs: nowMs, latencyMs, success: true });
@@ -253,172 +144,96 @@ export class HealthMonitor {
         return this.evaluate();
     }
     async evaluate(nowMs = Date.now()) {
-        const updatedAt = isoFromMs(nowMs);
-        const [runs, approvals, runtimeDbBytes, checkpointBytes, artifactBytes] = await Promise.all([
+        const updatedAt = new Date(nowMs).toISOString();
+        const [runs, approvals] = await Promise.all([
             this.options.persistence.listRuns(),
             this.options.persistence.listApprovals(),
-            this.sumRuntimeDbBytes(),
-            this.sumCheckpointDbBytes(),
-            this.sumArtifactBytes(),
         ]);
         const pendingApprovals = approvals.filter((approval) => approval.status === "pending").length;
         const stuckRuns = this.countStuckRuns(runs, nowMs);
-        const runtimeMaintenance = evaluateMaintenanceStatus("checkpoint", this.options.getCheckpointMaintenanceStatus(), updatedAt);
-        const recordMaintenance = evaluateMaintenanceStatus("records", this.options.getRuntimeRecordMaintenanceStatus(), updatedAt);
-        let runtimeCheck = buildCheck("healthy", updatedAt, "runtime loops healthy");
-        const runtimeSymptoms = [...runtimeMaintenance.symptoms, ...recordMaintenance.symptoms];
-        runtimeCheck = buildCheck(maxStatus(runtimeMaintenance.check.status, recordMaintenance.check.status), updatedAt, runtimeSymptoms.length > 0 ? runtimeSymptoms.map((symptom) => symptom.message).join("; ") : "runtime loops healthy");
         const llmCheck = this.evaluateLlmCheck(updatedAt, nowMs);
-        const persistenceCheck = this.evaluatePersistenceCheck(updatedAt, runtimeDbBytes, runtimeSymptoms);
-        const capacityCheck = this.evaluateCapacityCheck(updatedAt, checkpointBytes, runtimeDbBytes, artifactBytes);
         const workloadCheck = this.evaluateWorkloadCheck(updatedAt, pendingApprovals, stuckRuns);
-        const symptoms = [
-            ...runtimeSymptoms,
-            ...this.capacitySymptoms(capacityCheck, checkpointBytes, runtimeDbBytes, artifactBytes, updatedAt),
-            ...this.workloadSymptoms(workloadCheck, pendingApprovals, stuckRuns, updatedAt),
-            ...this.llmSymptoms(llmCheck, updatedAt),
-            ...(persistenceCheck.status === "healthy"
-                ? []
-                : [createSymptom("persistence.runtime-db", persistenceCheck.status, persistenceCheck.reason ?? "runtime persistence degraded", updatedAt)]),
-        ];
-        const checks = {
-            runtime: runtimeCheck,
-            llm: llmCheck,
-            persistence: persistenceCheck,
-            capacity: capacityCheck,
-            workload: workloadCheck,
-        };
+        const runtimeCheck = buildCheck("healthy", updatedAt, "runtime health monitoring enabled");
+        const persistenceCheck = buildCheck("healthy", updatedAt, "runtime persistence accessible");
+        const capacityCheck = buildCheck("healthy", updatedAt, "capacity checks disabled");
+        const symptoms = [];
+        if (describeThresholdStatus(pendingApprovals, this.config.thresholds.pendingApprovals) !== "healthy") {
+            symptoms.push(createSymptom("workload.pending-approvals", describeThresholdStatus(pendingApprovals, this.config.thresholds.pendingApprovals), `pendingApprovals=${pendingApprovals}`, updatedAt));
+        }
+        if (stuckRuns > 0) {
+            symptoms.push(createSymptom("workload.stuck-runs", workloadCheck.status, `stuckRuns=${stuckRuns}`, updatedAt));
+        }
+        if (llmCheck.status !== "healthy") {
+            symptoms.push(createSymptom("llm.invocations", llmCheck.status, llmCheck.reason ?? "llm health degraded", updatedAt));
+        }
         let overallStatus = "healthy";
-        for (const check of Object.values(checks)) {
+        for (const check of [runtimeCheck, llmCheck, persistenceCheck, capacityCheck, workloadCheck]) {
             overallStatus = maxStatus(overallStatus, check.status);
         }
         const snapshot = {
             status: overallStatus,
             updatedAt,
-            checks,
+            checks: {
+                runtime: runtimeCheck,
+                llm: llmCheck,
+                persistence: persistenceCheck,
+                capacity: capacityCheck,
+                workload: workloadCheck,
+            },
             symptoms,
             stats: {
                 activeRunSlots: this.options.getActiveRunSlots(),
                 pendingRunSlots: this.options.getPendingRunSlots(),
                 pendingApprovals,
                 stuckRuns,
-                checkpointBytes,
-                runtimeDbBytes,
-                artifactBytes,
                 ...this.llmStats(nowMs),
             },
         };
-        const previous = this.latestSnapshot;
-        this.latestSnapshot = snapshot;
         if (this.config.enabled &&
             this.config.emitEvents &&
             this.options.publishEvent &&
-            previous &&
-            !compareStatus(previous.status, snapshot.status)) {
+            this.latestSnapshot &&
+            this.latestSnapshot.status !== snapshot.status) {
             await this.options.publishEvent({
-                previousStatus: previous.status,
+                previousStatus: this.latestSnapshot.status,
                 status: snapshot.status,
                 checks: snapshot.checks,
                 stats: snapshot.stats,
             });
         }
+        this.latestSnapshot = snapshot;
         return snapshot;
     }
     llmStats(nowMs) {
-        const oneMinuteWindowMs = 60 * 1000;
-        const recent = this.llmSamples.filter((sample) => nowMs - sample.timestampMs <= oneMinuteWindowMs);
+        const recent = this.llmSamples.filter((sample) => nowMs - sample.timestampMs <= 60 * 1000);
         const successes = recent.filter((sample) => sample.success).length;
-        const latencies = recent.map((sample) => sample.latencyMs);
         return {
             llmSuccessRate1m: recent.length > 0 ? successes / recent.length : undefined,
-            llmP95LatencyMs1m: computeP95(latencies),
+            llmP95LatencyMs1m: computeP95(recent.map((sample) => sample.latencyMs)),
         };
     }
     evaluateLlmCheck(updatedAt, nowMs) {
-        const errorWindow = this.config.thresholds.llmErrorRate.windowSeconds * 1000;
-        const latencyWindow = this.config.thresholds.llmP95LatencyMs.windowSeconds * 1000;
-        const errorSamples = this.llmSamples.filter((sample) => nowMs - sample.timestampMs <= errorWindow);
-        const latencySamples = this.llmSamples.filter((sample) => nowMs - sample.timestampMs <= latencyWindow);
+        const errorSamples = this.llmSamples.filter((sample) => nowMs - sample.timestampMs <= this.config.thresholds.llmErrorRate.windowSeconds * 1000);
+        const latencySamples = this.llmSamples.filter((sample) => nowMs - sample.timestampMs <= this.config.thresholds.llmP95LatencyMs.windowSeconds * 1000);
         if (errorSamples.length === 0 && latencySamples.length === 0) {
             return buildCheck("healthy", updatedAt, "no recent llm invocations");
         }
-        const errors = errorSamples.filter((sample) => !sample.success).length;
-        const errorRate = errorSamples.length > 0 ? errors / errorSamples.length : 0;
+        const errorRate = errorSamples.length > 0
+            ? errorSamples.filter((sample) => !sample.success).length / errorSamples.length
+            : 0;
         const p95Latency = computeP95(latencySamples.map((sample) => sample.latencyMs));
-        let status = "healthy";
-        if (errorRate >= this.config.thresholds.llmErrorRate.unhealthyAbove) {
-            status = "unhealthy";
-        }
-        else if (errorRate >= this.config.thresholds.llmErrorRate.degradedAbove) {
-            status = "degraded";
-        }
+        let status = describeThresholdStatus(errorRate, this.config.thresholds.llmErrorRate);
         if (p95Latency !== undefined) {
-            const latencyStatus = describeThresholdStatus(p95Latency, this.config.thresholds.llmP95LatencyMs);
-            status = maxStatus(status, latencyStatus);
+            status = maxStatus(status, describeThresholdStatus(p95Latency, this.config.thresholds.llmP95LatencyMs));
         }
         return buildCheck(status, updatedAt, `errorRate=${errorRate.toFixed(2)}${p95Latency !== undefined ? ` p95LatencyMs=${Math.round(p95Latency)}` : ""}`);
     }
-    llmSymptoms(check, updatedAt) {
-        if (check.status === "healthy") {
-            return [];
-        }
-        return [createSymptom("llm.invocations", check.status, check.reason ?? "llm health degraded", updatedAt)];
-    }
-    evaluatePersistenceCheck(updatedAt, runtimeDbBytes, runtimeSymptoms) {
-        if (runtimeSymptoms.length > 0) {
-            return buildCheck("degraded", updatedAt, runtimeSymptoms.map((symptom) => symptom.message).join("; "));
-        }
-        if (runtimeDbBytes === 0) {
-            return buildCheck("healthy", updatedAt, "runtime sqlite not materialized yet");
-        }
-        return buildCheck("healthy", updatedAt, "runtime sqlite accessible");
-    }
-    evaluateCapacityCheck(updatedAt, checkpointBytes, runtimeDbBytes, artifactBytes) {
-        let status = "healthy";
-        status = maxStatus(status, describeThresholdStatus(checkpointBytes, this.config.thresholds.checkpointBytes));
-        status = maxStatus(status, describeThresholdStatus(runtimeDbBytes, this.config.thresholds.runtimeDbBytes));
-        status = maxStatus(status, describeThresholdStatus(artifactBytes, this.config.thresholds.artifactBytes));
-        return buildCheck(status, updatedAt, `checkpointBytes=${checkpointBytes} runtimeDbBytes=${runtimeDbBytes} artifactBytes=${artifactBytes}`);
-    }
-    capacitySymptoms(check, checkpointBytes, runtimeDbBytes, artifactBytes, updatedAt) {
-        if (check.status === "healthy") {
-            return [];
-        }
-        const symptoms = [];
-        if (describeThresholdStatus(checkpointBytes, this.config.thresholds.checkpointBytes) !== "healthy") {
-            symptoms.push(createSymptom("capacity.checkpoints", describeThresholdStatus(checkpointBytes, this.config.thresholds.checkpointBytes), `checkpointBytes=${checkpointBytes}`, updatedAt));
-        }
-        if (describeThresholdStatus(runtimeDbBytes, this.config.thresholds.runtimeDbBytes) !== "healthy") {
-            symptoms.push(createSymptom("capacity.runtime-db", describeThresholdStatus(runtimeDbBytes, this.config.thresholds.runtimeDbBytes), `runtimeDbBytes=${runtimeDbBytes}`, updatedAt));
-        }
-        if (describeThresholdStatus(artifactBytes, this.config.thresholds.artifactBytes) !== "healthy") {
-            symptoms.push(createSymptom("capacity.artifacts", describeThresholdStatus(artifactBytes, this.config.thresholds.artifactBytes), `artifactBytes=${artifactBytes}`, updatedAt));
-        }
-        return symptoms;
-    }
     evaluateWorkloadCheck(updatedAt, pendingApprovals, stuckRuns) {
         let status = describeThresholdStatus(pendingApprovals, this.config.thresholds.pendingApprovals);
-        status = maxStatus(status, describeThresholdStatus(stuckRuns, {
-            degradedAbove: this.config.thresholds.stuckRunSeconds.degradedAbove > 0 ? 1 : Number.MAX_SAFE_INTEGER,
-            unhealthyAbove: this.config.thresholds.stuckRunSeconds.unhealthyAbove > 0 ? 1 : Number.MAX_SAFE_INTEGER,
-        }));
-        return buildCheck(status, updatedAt, `pendingApprovals=${pendingApprovals} stuckRuns=${stuckRuns}`);
-    }
-    workloadSymptoms(check, pendingApprovals, stuckRuns, updatedAt) {
-        if (check.status === "healthy") {
-            return [];
-        }
-        const symptoms = [];
-        if (describeThresholdStatus(pendingApprovals, this.config.thresholds.pendingApprovals) !== "healthy") {
-            symptoms.push(createSymptom("workload.pending-approvals", describeThresholdStatus(pendingApprovals, this.config.thresholds.pendingApprovals), `pendingApprovals=${pendingApprovals}`, updatedAt));
-        }
         if (stuckRuns > 0) {
-            const stuckStatus = stuckRuns >= 1 && this.config.thresholds.stuckRunSeconds.unhealthyAbove <= this.config.thresholds.stuckRunSeconds.degradedAbove
-                ? "unhealthy"
-                : "degraded";
-            symptoms.push(createSymptom("workload.stuck-runs", stuckStatus, `stuckRuns=${stuckRuns}`, updatedAt));
+            status = maxStatus(status, stuckRuns >= this.config.thresholds.stuckRunSeconds.unhealthyAbove ? "unhealthy" : "degraded");
         }
-        return symptoms;
+        return buildCheck(status, updatedAt, `pendingApprovals=${pendingApprovals} stuckRuns=${stuckRuns}`);
     }
     countStuckRuns(runs, nowMs) {
         return runs.filter((run) => {
@@ -429,20 +244,7 @@ export class HealthMonitor {
             if (!Number.isFinite(updatedAtMs)) {
                 return false;
             }
-            const ageSeconds = (nowMs - updatedAtMs) / 1000;
-            return ageSeconds >= this.config.thresholds.stuckRunSeconds.degradedAbove;
+            return (nowMs - updatedAtMs) / 1000 >= this.config.thresholds.stuckRunSeconds.degradedAbove;
         }).length;
     }
-    async sumRuntimeDbBytes() {
-        const sizes = await Promise.all(this.runRoots.map((runRoot) => safeFileSize(path.join(runRoot, "runtime.sqlite"))));
-        return sizes.reduce((sum, value) => sum + value, 0);
-    }
-    async sumCheckpointDbBytes() {
-        const sizes = await Promise.all(this.checkpointDbPaths.map((dbPath) => safeFileSize(dbPath)));
-        return sizes.reduce((sum, value) => sum + value, 0);
-    }
-    async sumArtifactBytes() {
-        const sizes = await Promise.all(this.runRoots.map((runRoot) => directorySize(path.join(runRoot, "threads"))));
-        return sizes.reduce((sum, value) => sum + value, 0);
-    }
 }

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

@@ -2,9 +2,8 @@ import { readSkillMetadata } from "../../support/skill-metadata.js";
 import { getBindingPrimaryTools } from "../../support/compiled-binding.js";
 import { assessSkillRequirements, } from "./skill-requirements.js";
 import { createRuntimeEnv } from "../../support/runtime-env.js";
-import { isRuntimeEntryBinding } from "../../support/runtime-entry.js";
 function listHostBindings(workspace) {
-    return Array.from(workspace.bindings.values()).filter((binding) => isRuntimeEntryBinding(binding));
+    return Array.from(workspace.bindings.values());
 }
 export function findAgentBinding(workspace, agentId) {
     return workspace.bindings.get(agentId);

package/dist/runtime/harness.d.ts

@@ -5,7 +5,6 @@ import type { RequirementAssessmentOptions } from "./harness/system/skill-requir
 export declare class AgentHarnessRuntime {
     private readonly workspace;
     private readonly runtimeAdapterOptions;
-    private static readonly DEFAULT_HOST_AGENT_ID;
     private static readonly BACKGROUND_EVENT_TYPES;
     private readonly eventBus;
     private readonly persistence;

package/dist/runtime/harness.js

@@ -23,7 +23,6 @@ import { getDefaultHostAgentId, resolveSelectedAgentId } from "./harness/run/rou
 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";
 import { initializeHarnessRuntime, isStaleRunningRun as isHarnessStaleRunningRun, } from "./harness/run/startup-runtime.js";
@@ -32,7 +31,6 @@ import { deleteThreadRecord, getPublicApproval, getThreadRecord, listPublicAppro
 export class AgentHarnessRuntime {
     workspace;
     runtimeAdapterOptions;
-    static DEFAULT_HOST_AGENT_ID = "orchestra";
     static BACKGROUND_EVENT_TYPES = new Set([
         "run.created",
         "run.queued",
@@ -72,7 +70,7 @@ export class AgentHarnessRuntime {
             `${this.workspace.workspaceRoot}/run-data`);
     }
     getDefaultHostAgentId() {
-        return getDefaultHostAgentId(this.workspace, this.routingDefaultAgentId ?? AgentHarnessRuntime.DEFAULT_HOST_AGENT_ID);
+        return getDefaultHostAgentId(this.workspace, this.routingDefaultAgentId);
     }
     async resolveSelectedAgentId(input, requestedAgentId, threadId) {
         return resolveSelectedAgentId({
@@ -80,7 +78,7 @@ export class AgentHarnessRuntime {
             input,
             requestedAgentId,
             threadId,
-            preferredHostAgentId: this.routingDefaultAgentId ?? AgentHarnessRuntime.DEFAULT_HOST_AGENT_ID,
+            preferredHostAgentId: this.routingDefaultAgentId,
             getThreadSummary: (currentThreadId) => this.getSession(currentThreadId),
         });
     }
@@ -264,14 +262,14 @@ export class AgentHarnessRuntime {
         const configuredRule = this.routingRules.find((rule) => matchRoutingRule(rawInput, rule, options));
         if (configuredRule) {
             const configuredBinding = this.workspace.bindings.get(configuredRule.agentId);
-            if (configuredBinding && isRuntimeEntryBinding(configuredBinding)) {
+            if (configuredBinding) {
                 return configuredBinding.agent.id;
             }
         }
         const defaultBinding = this.routingDefaultAgentId
             ? this.workspace.bindings.get(this.routingDefaultAgentId)
             : undefined;
-        if (defaultBinding && isRuntimeEntryBinding(defaultBinding)) {
+        if (defaultBinding) {
             return defaultBinding.agent.id;
         }
         return this.getDefaultHostAgentId();

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

@@ -11,7 +11,5 @@ export declare function createHarnessEvent(threadId: string, runId: string, sequ
 export declare function createPendingApproval(threadId: string, runId: string, checkpointRef: string, input: string, interruptContent?: string): InternalApprovalRecord;
 export declare function inferRoutingBindings(workspace: WorkspaceBundle): {
     primaryBinding: import("../../contracts/workspace.js").CompiledAgentBinding;
-    secondaryBinding: import("../../contracts/workspace.js").CompiledAgentBinding | undefined;
-    researchBinding: import("../../contracts/workspace.js").CompiledAgentBinding | undefined;
     hostBindings: import("../../contracts/workspace.js").CompiledAgentBinding[];
 };

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

@@ -1,6 +1,5 @@
 import { createPersistentId } from "../../utils/id.js";
 import { isDelegationCapableBinding } from "../../workspace/support/agent-capabilities.js";
-import { isRuntimeEntryBinding } from "./runtime-entry.js";
 export function renderRuntimeFailure(error) {
     const message = error instanceof Error ? error.message : String(error);
     return `runtime_error=${message}`.trim();
@@ -87,38 +86,9 @@ export function createPendingApproval(threadId, runId, checkpointRef, input, int
     };
 }
 export function inferRoutingBindings(workspace) {
-    const runtimeEntryBindings = Array.from(workspace.bindings.values()).filter((binding) => isRuntimeEntryBinding(binding));
-    const orchestrationHosts = runtimeEntryBindings.filter((binding) => binding.agent.executionMode === "deepagent" || Boolean(binding.deepAgentParams));
-    const routingHosts = orchestrationHosts.length > 0 ? orchestrationHosts : runtimeEntryBindings;
-    const deepAgentHosts = routingHosts.filter((binding) => binding.agent.executionMode === "deepagent" || Boolean(binding.deepAgentParams));
-    const nonDeepAgentHosts = routingHosts.filter((binding) => !deepAgentHosts.includes(binding));
-    const researchBinding = routingHosts.find((binding) => binding.agent.id === "research-lite" || binding.agent.id === "research");
-    const directBinding = routingHosts.find((binding) => binding.agent.id === "direct");
-    const delegationHosts = routingHosts.filter((binding) => isDelegationCapableBinding(binding));
-    const deepAgentDelegationHosts = deepAgentHosts.filter((binding) => isDelegationCapableBinding(binding));
-    const nonDeepAgentDelegationHosts = nonDeepAgentHosts.filter((binding) => isDelegationCapableBinding(binding));
-    const lightweightHosts = routingHosts.filter((binding) => !isDelegationCapableBinding(binding));
-    const defaultOrchestratingHost = routingHosts.find((binding) => binding.agent.id === "orchestra") ??
-        deepAgentDelegationHosts.find((binding) => (binding.deepAgentParams?.subagents.length ?? 0) > 0) ??
-        deepAgentDelegationHosts[0] ??
-        deepAgentHosts[0] ??
-        nonDeepAgentDelegationHosts.find((binding) => (binding.deepAgentParams?.subagents.length ?? 0) > 0) ??
-        nonDeepAgentDelegationHosts[0] ??
-        nonDeepAgentHosts[0];
-    const delegationPreferredSecondary = deepAgentDelegationHosts.find((binding) => (binding.deepAgentParams?.subagents.length ?? 0) > 0) ??
-        deepAgentDelegationHosts[0] ??
-        nonDeepAgentDelegationHosts.find((binding) => (binding.deepAgentParams?.subagents.length ?? 0) > 0) ??
-        nonDeepAgentDelegationHosts[0] ??
-        delegationHosts[0];
-    const genericLightweightHost = lightweightHosts.find((binding) => binding.agent.id !== researchBinding?.agent.id);
-    const primaryBinding = defaultOrchestratingHost ?? directBinding ?? genericLightweightHost ?? routingHosts[0] ?? runtimeEntryBindings[0];
-    const secondaryBinding = genericLightweightHost && genericLightweightHost.agent.id !== primaryBinding?.agent.id
-        ? genericLightweightHost
-        : directBinding && directBinding.agent.id !== primaryBinding?.agent.id
-            ? directBinding
-            : delegationPreferredSecondary && delegationPreferredSecondary.agent.id !== primaryBinding?.agent.id
-                ? delegationPreferredSecondary
-                : routingHosts.find((binding) => binding.agent.id !== primaryBinding?.agent.id) ??
-                    (orchestrationHosts.length > 0 ? undefined : runtimeEntryBindings.find((binding) => binding.agent.id !== primaryBinding?.agent.id));
-    return { primaryBinding, secondaryBinding, researchBinding, hostBindings: runtimeEntryBindings };
+    const hostBindings = Array.from(workspace.bindings.values());
+    const orchestrationHosts = hostBindings.filter((binding) => binding.agent.executionMode === "deepagent" || Boolean(binding.deepAgentParams));
+    const routingHosts = orchestrationHosts.length > 0 ? orchestrationHosts : hostBindings;
+    const primaryBinding = routingHosts.find((binding) => isDelegationCapableBinding(binding)) ?? routingHosts[0] ?? hostBindings[0];
+    return { primaryBinding, hostBindings };
 }

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

@@ -72,9 +72,6 @@ function resolveAgentRuntimeName(agent) {
     if (normalizedSourcePath.includes("/packages/framework/")) {
         return `core.${baseName}`;
     }
-    if (["direct", "orchestra", "research-lite"].includes(baseName)) {
-        return `core.${baseName}`;
-    }
     return baseName;
 }
 export function requireTools(tools, refs, ownerId) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.104",
+  "version": "0.0.106",
   "description": "Workspace runtime for multi-agent applications",
   "type": "module",
   "packageManager": "npm@10.9.2",

package/dist/runtime/support/runtime-entry.d.ts

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

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

@@ -1,3 +0,0 @@
-export function isRuntimeEntryBinding(binding) {
-    return Boolean(binding);
-}