@botbotgo/agent-harness 0.0.259 → 0.0.261

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.258";
+export declare const AGENT_HARNESS_VERSION = "0.0.260";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.258";
+export const AGENT_HARNESS_VERSION = "0.0.260";

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

@@ -8,6 +8,7 @@ type Startable = {
 export declare function initializeHarnessRuntime(input: {
     persistence: RuntimePersistence;
     healthMonitor: Startable | null;
+    scheduleBackgroundTask?: (task: Promise<void>) => void;
 }): Promise<void>;
 export declare function recoverStartupRuns(input: {
     recoveryConfig: RecoveryConfig;

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

@@ -3,7 +3,13 @@ import { traceStartupStage } from "../../startup-tracing.js";
 export async function initializeHarnessRuntime(input) {
     await traceStartupStage("runtime.initialize.persistence", () => input.persistence.initialize());
     if (input.healthMonitor) {
-        await traceStartupStage("runtime.initialize.healthMonitor", () => input.healthMonitor.start());
+        const healthMonitorStartTask = traceStartupStage("runtime.initialize.healthMonitor", () => input.healthMonitor.start());
+        if (input.scheduleBackgroundTask) {
+            input.scheduleBackgroundTask(healthMonitorStartTask);
+        }
+        else {
+            await healthMonitorStartTask;
+        }
     }
 }
 export async function recoverStartupRuns(input) {

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

@@ -24,6 +24,14 @@ const DEFAULT_HEALTH_CONFIG = {
         },
     },
 };
+const ACTIVE_RUN_STATES = [
+    "queued",
+    "claimed",
+    "running",
+    "waiting_for_approval",
+    "resuming",
+    "cancelling",
+];
 function asObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
 }
@@ -146,10 +154,10 @@ export class HealthMonitor {
     async evaluate(nowMs = Date.now()) {
         const updatedAt = new Date(nowMs).toISOString();
         const [runs, approvals] = await Promise.all([
-            this.options.persistence.listRuns(),
-            this.options.persistence.listApprovals(),
+            Promise.all(ACTIVE_RUN_STATES.map((state) => this.options.persistence.listRuns({ state }))).then((groups) => groups.flat()),
+            this.options.persistence.listApprovals({ status: "pending" }),
         ]);
-        const pendingApprovals = approvals.filter((approval) => approval.status === "pending").length;
+        const pendingApprovals = approvals.length;
         const stuckRuns = this.countStuckRuns(runs, nowMs);
         const llmCheck = this.evaluateLlmCheck(updatedAt, nowMs);
         const workloadCheck = this.evaluateWorkloadCheck(updatedAt, pendingApprovals, stuckRuns);

package/dist/runtime/harness.d.ts

@@ -127,6 +127,7 @@ export declare class AgentHarnessRuntime {
     }): Promise<string>;
     private emit;
     private trackBackgroundTask;
+    private scheduleBackgroundStartupTask;
     private resolveToolMcpServerTools;
     private loadPriorHistory;
     private loadRunInput;

package/dist/runtime/harness.js

@@ -43,6 +43,14 @@ import { normalizeProcessExecutablePath } from "./support/runtime-env.js";
 import { streamHarnessRun } from "./harness/run/stream-run.js";
 import { defaultRequestedAgentId, prepareRunStart } from "./harness/run/start-run.js";
 import { buildRequestInspectionRecord, buildSessionInspectionRecord, deleteSessionRecord, deleteThreadRecord, getPublicApproval, listPublicApprovals, } from "./harness/run/thread-records.js";
+const ACTIVE_RUN_STATES = [
+    "queued",
+    "claimed",
+    "running",
+    "waiting_for_approval",
+    "resuming",
+    "cancelling",
+];
 function normalizeSessionListText(content, limit) {
     if (!content) {
         return undefined;
@@ -324,8 +332,9 @@ export class AgentHarnessRuntime {
         await initializeHarnessRuntime({
             persistence: this.persistence,
             healthMonitor: this.healthMonitor,
+            scheduleBackgroundTask: (task) => this.scheduleBackgroundStartupTask(task),
         });
-        await traceStartupStage("runtime.initialize.startupRecovery", () => this.recoverStartupRuns());
+        this.scheduleBackgroundStartupTask(traceStartupStage("runtime.initialize.startupRecovery", () => this.recoverStartupRuns()));
         this.initialized = true;
     }
     subscribe(listener) {
@@ -340,8 +349,8 @@ export class AgentHarnessRuntime {
     async getOperatorOverview(options) {
         const [health, runs, approvals] = await Promise.all([
             this.getHealth(),
-            this.listRuns(),
-            this.listApprovals(),
+            Promise.all(ACTIVE_RUN_STATES.map((state) => this.listRuns({ state }))).then((groups) => groups.flat()),
+            this.listApprovals({ status: "pending" }),
         ]);
         return projectOperatorOverview({
             health,
@@ -954,6 +963,9 @@ export class AgentHarnessRuntime {
             this.backgroundTasks.delete(task);
         });
     }
+    scheduleBackgroundStartupTask(task) {
+        this.trackBackgroundTask(task.then(() => undefined).catch(() => undefined));
+    }
     resolveToolMcpServerTools(agentId) {
         return resolveWorkspaceAgentTools({
             workspace: this.workspace,

package/dist/workspace/compile.js

@@ -267,8 +267,25 @@ export async function loadWorkspace(workspaceRoot, options = {}) {
         ...(localResourceRoot ? [localResourceRoot] : []),
         ...collectedResources,
     ]));
-    validateWorkspaceResources(embeddings, mcpServers, models, vectorStores, tools, loaded.agents);
-    validateRoutingTargets(loaded.refs, loaded.agents);
+    await traceStartupStage("workspace.validate.resources", async () => {
+        validateWorkspaceResources(embeddings, mcpServers, models, vectorStores, tools, loaded.agents);
+    }, {
+        workspaceRoot,
+        agentCount: loaded.agents.length,
+        toolCount: tools.size,
+        modelCount: models.size,
+        mcpServerCount: mcpServers.size,
+    });
+    await traceStartupStage("workspace.validate.routingTargets", async () => {
+        validateRoutingTargets(loaded.refs, loaded.agents);
+    }, {
+        workspaceRoot,
+        agentCount: loaded.agents.length,
+    });
+    const bindings = await traceStartupStage("workspace.compile.bindings", async () => compileBindings(workspaceRoot, loaded.refs, loaded.agents, models, tools), {
+        workspaceRoot,
+        agentCount: loaded.agents.length,
+    });
     return {
         workspaceRoot,
         resources,
@@ -279,6 +296,6 @@ export async function loadWorkspace(workspaceRoot, options = {}) {
         vectorStores,
         tools,
         agents: new Map(loaded.agents.map((agent) => [agent.id, agent])),
-        bindings: compileBindings(workspaceRoot, loaded.refs, loaded.agents, models, tools),
+        bindings,
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.259",
+  "version": "0.0.261",
   "description": "Workspace runtime for multi-agent applications",
   "license": "MIT",
   "type": "module",