@botbotgo/agent-harness 0.0.257 → 0.0.259

package/dist/api.js

@@ -6,6 +6,7 @@ import { serveAcpOverHttp } from "./protocol/acp/http.js";
 import { serveAcpOverStdio } from "./protocol/acp/stdio.js";
 import { normalizeMessageContent } from "./utils/message-content.js";
 import { loadWorkspace } from "./workspace/compile.js";
+import { traceStartupStage } from "./runtime/startup-tracing.js";
 export { AgentHarnessAcpServer, createAcpServer } from "./acp.js";
 export { createAcpStdioClient } from "./protocol/acp/client.js";
 export { AgentHarnessRuntime } from "./runtime/harness.js";
@@ -173,9 +174,15 @@ function toPublicRequestSummary(run) {
     };
 }
 export async function createAgentHarness(workspaceRoot = process.cwd(), options = {}) {
-    const workspace = await loadWorkspace(workspaceRoot, options.load ?? {});
-    const harness = new AgentHarnessRuntime(workspace, options.adapter ?? {});
-    await harness.initialize();
+    const workspace = await traceStartupStage("createAgentHarness.loadWorkspace", () => loadWorkspace(workspaceRoot, options.load ?? {}), {
+        workspaceRoot,
+    });
+    const harness = await traceStartupStage("createAgentHarness.constructRuntime", async () => new AgentHarnessRuntime(workspace, options.adapter ?? {}), {
+        workspaceRoot,
+    });
+    await traceStartupStage("createAgentHarness.initializeRuntime", () => harness.initialize(), {
+        workspaceRoot,
+    });
     return harness;
 }
 export function normalizeUserChatInput(input, options = {}) {

package/dist/package-version.d.ts

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

package/dist/package-version.js

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

package/dist/persistence/sqlite-store.d.ts

@@ -22,6 +22,7 @@ export declare class SqlitePersistence implements RuntimePersistence {
     private selectAll;
     private mapThreadSummary;
     private mapRunSummary;
+    private listRunSnapshots;
     private mapApproval;
     initialize(): Promise<void>;
     private ensureSchemaMetadata;

package/dist/persistence/sqlite-store.js

@@ -6,6 +6,14 @@ import { SqliteRunContextStore } from "./sqlite-run-context-store.js";
 import { SqliteRunQueueStore } from "./sqlite-run-queue-store.js";
 const RUNTIME_SQLITE_SCHEMA_VERSION = 6;
 const RUNTIME_SQLITE_SCHEMA_FAMILY = "agent-harness-runtime";
+const ACTIVE_RUN_STATES = new Set([
+    "queued",
+    "claimed",
+    "running",
+    "waiting_for_approval",
+    "resuming",
+    "cancelling",
+]);
 function asRow(value) {
     return value;
 }
@@ -211,6 +219,7 @@ export class SqlitePersistence {
       `);
             await this.rawExecute("CREATE INDEX IF NOT EXISTS runs_thread_updated_idx ON runs(thread_id, updated_at DESC)");
             await this.rawExecute("CREATE INDEX IF NOT EXISTS runs_thread_created_idx ON runs(thread_id, created_at DESC)");
+            await this.rawExecute("CREATE INDEX IF NOT EXISTS runs_updated_idx ON runs(updated_at DESC)");
             await this.rawExecute("CREATE INDEX IF NOT EXISTS runs_state_updated_idx ON runs(state, updated_at DESC)");
             await this.rawExecute("CREATE INDEX IF NOT EXISTS runs_agent_updated_idx ON runs(agent_id, updated_at DESC)");
             await this.rawExecute("CREATE INDEX IF NOT EXISTS run_inspection_thread_activity_idx ON run_inspection(thread_id, last_activity_at DESC)");
@@ -434,6 +443,17 @@ export class SqlitePersistence {
             ...(runtimeSnapshot ? { runtimeSnapshot } : {}),
         };
     }
+    async listRunSnapshots(runIds) {
+        if (runIds.length === 0) {
+            return new Map();
+        }
+        const placeholders = runIds.map(() => "?").join(", ");
+        const rows = await this.selectAll(`SELECT run_id, runtime_snapshot_json
+       FROM run_inspection
+       WHERE run_id IN (${placeholders})
+         AND runtime_snapshot_json IS NOT NULL`, runIds);
+        return new Map(rows.map((row) => [asString(row.run_id), parseJson(row.runtime_snapshot_json)]));
+    }
     mapApproval(row) {
         return {
             approvalId: asString(row.approval_id),
@@ -751,12 +771,23 @@ export class SqlitePersistence {
             ["runs.state = ?", filter.state],
         ]);
         const rows = await this.selectAll(`SELECT runs.run_id, runs.thread_id, runs.agent_id, runs.parent_run_id, runs.execution_mode, runs.adapter_kind, runs.created_at, runs.updated_at, runs.state, runs.checkpoint_ref, runs.resumable,
-              run_inspection.started_at, run_inspection.ended_at, run_inspection.last_activity_at, run_inspection.current_agent_id, run_inspection.delegation_chain_json, run_inspection.runtime_snapshot_json
+              run_inspection.started_at, run_inspection.ended_at, run_inspection.last_activity_at, run_inspection.current_agent_id, run_inspection.delegation_chain_json
        FROM runs
        LEFT JOIN run_inspection ON run_inspection.run_id = runs.run_id
        ${clause}
-       ORDER BY updated_at DESC`, args);
-        return rows.map((row) => this.mapRunSummary(row));
+       ORDER BY runs.updated_at DESC`, args);
+        const activeRunIds = rows
+            .filter((row) => ACTIVE_RUN_STATES.has(asString(row.state)))
+            .map((row) => asString(row.run_id));
+        const snapshotsByRunId = await this.listRunSnapshots(activeRunIds);
+        return rows.map((row) => {
+            const runId = asString(row.run_id);
+            const runtimeSnapshot = snapshotsByRunId.get(runId);
+            return {
+                ...this.mapRunSummary(row),
+                ...(runtimeSnapshot ? { runtimeSnapshot } : {}),
+            };
+        });
     }
     async getRun(runId) {
         const row = await this.selectOne(`SELECT runs.run_id, runs.thread_id, runs.agent_id, runs.parent_run_id, runs.execution_mode, runs.adapter_kind, runs.created_at, runs.updated_at, runs.state, runs.checkpoint_ref, runs.resumable,

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

@@ -1,7 +1,10 @@
 import { recoverQueuedStartupRun, recoverResumingStartupRun, recoverRunningStartupRun, } from "./recovery.js";
+import { traceStartupStage } from "../../startup-tracing.js";
 export async function initializeHarnessRuntime(input) {
-    await input.persistence.initialize();
-    await input.healthMonitor?.start();
+    await traceStartupStage("runtime.initialize.persistence", () => input.persistence.initialize());
+    if (input.healthMonitor) {
+        await traceStartupStage("runtime.initialize.healthMonitor", () => input.healthMonitor.start());
+    }
 }
 export async function recoverStartupRuns(input) {
     if (!input.recoveryConfig.enabled) {

package/dist/runtime/harness.js

@@ -38,6 +38,7 @@ import { consolidateStructuredMemoryScope } from "./harness/system/runtime-memor
 import { normalizeLangMemMemoryKind, readRuntimeMemoryMaintenanceConfig, readRuntimeMemoryPolicyConfig, resolveMemoryNamespace, scoreMemoryText, } from "./harness/system/runtime-memory-policy.js";
 import { resolveRuntimeAdapterOptions } from "./support/runtime-adapter-options.js";
 import { initializeHarnessRuntime, reclaimExpiredClaimedRuns as reclaimHarnessExpiredClaimedRuns, recoverStartupRuns as recoverHarnessStartupRuns, isStaleRunningRun as isHarnessStaleRunningRun, } from "./harness/run/startup-runtime.js";
+import { traceStartupStage } from "./startup-tracing.js";
 import { normalizeProcessExecutablePath } from "./support/runtime-env.js";
 import { streamHarnessRun } from "./harness/run/stream-run.js";
 import { defaultRequestedAgentId, prepareRunStart } from "./harness/run/start-run.js";
@@ -324,7 +325,7 @@ export class AgentHarnessRuntime {
             persistence: this.persistence,
             healthMonitor: this.healthMonitor,
         });
-        await this.recoverStartupRuns();
+        await traceStartupStage("runtime.initialize.startupRecovery", () => this.recoverStartupRuns());
         this.initialized = true;
     }
     subscribe(listener) {

package/dist/runtime/startup-tracing.d.ts

@@ -0,0 +1 @@
+export declare function traceStartupStage<T>(stage: string, operation: () => Promise<T>, detail?: Record<string, unknown>): Promise<T>;

package/dist/runtime/startup-tracing.js

@@ -0,0 +1,37 @@
+function startupTimingEnabled() {
+    return process.env.AGENT_HARNESS_STARTUP_TIMING === "1";
+}
+function formatDurationMs(startedAt) {
+    return (Date.now() - startedAt).toString();
+}
+function writeStartupTrace(stage, phase, durationMs, detail) {
+    if (!startupTimingEnabled()) {
+        return;
+    }
+    const fields = [
+        "[agent-harness.startup]",
+        `stage=${stage}`,
+        `phase=${phase}`,
+        ...(durationMs ? [`durationMs=${durationMs}`] : []),
+        ...Object.entries(detail ?? {})
+            .filter(([, value]) => value !== undefined && value !== null && `${value}`.length > 0)
+            .map(([key, value]) => `${key}=${JSON.stringify(value)}`),
+    ];
+    process.stderr.write(`${fields.join(" ")}\n`);
+}
+export async function traceStartupStage(stage, operation, detail) {
+    const startedAt = Date.now();
+    writeStartupTrace(stage, "start", undefined, detail);
+    try {
+        const result = await operation();
+        writeStartupTrace(stage, "success", formatDurationMs(startedAt), detail);
+        return result;
+    }
+    catch (error) {
+        writeStartupTrace(stage, "failure", formatDurationMs(startedAt), {
+            ...detail,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        throw error;
+    }
+}

package/dist/workspace/compile.js

@@ -12,6 +12,7 @@ import { discoverSubagents, ensureDiscoverySources } from "./support/discovery.j
 import { collectAgentDiscoverySourceRefs, collectToolSourceRefs } from "./support/source-collectors.js";
 import { getRoutingDefaultAgentId, getRuntimeResources, getRoutingRules, resolveRefId, } from "./support/workspace-ref-utils.js";
 import { hydrateAgentMcpTools, hydrateResourceAndExternalTools } from "./tool-hydration.js";
+import { traceStartupStage } from "../runtime/startup-tracing.js";
 function collectParsedResources(refs) {
     const embeddings = new Map();
     const mcpServers = new Map();
@@ -204,22 +205,38 @@ function resolveAgentSkillNames(agents, skillRegistry, skillCollectionRoots) {
     }
 }
 export async function loadWorkspace(workspaceRoot, options = {}) {
-    const loaded = await loadWorkspaceObjects(workspaceRoot, options);
-    loaded.agents = await discoverSubagents(loaded.agents, workspaceRoot);
+    const loaded = await traceStartupStage("workspace.load.objects", () => loadWorkspaceObjects(workspaceRoot, options), {
+        workspaceRoot,
+    });
+    loaded.agents = await traceStartupStage("workspace.discover.subagents", () => discoverSubagents(loaded.agents, workspaceRoot), {
+        workspaceRoot,
+    });
     const discoverySourceRefs = collectAgentDiscoverySourceRefs(loaded.agents);
-    await ensureDiscoverySources(discoverySourceRefs, workspaceRoot);
+    await traceStartupStage("workspace.ensure.discoverySources", () => ensureDiscoverySources(discoverySourceRefs, workspaceRoot), {
+        workspaceRoot,
+        sourceCount: discoverySourceRefs.length,
+    });
     for (const agent of loaded.agents) {
         loaded.refs.set(`agent/${agent.id}`, agent);
     }
     const { embeddings, mcpServers, models, vectorStores, tools } = collectParsedResources(loaded.refs);
-    await hydrateAgentMcpTools(loaded.agents, mcpServers, tools);
+    await traceStartupStage("workspace.hydrate.agentMcpTools", () => hydrateAgentMcpTools(loaded.agents, mcpServers, tools), {
+        workspaceRoot,
+        agentCount: loaded.agents.length,
+    });
     const configuredResources = Array.from(new Set([
         ...getRuntimeResources(loaded.refs),
         ...(options.resources ?? []),
     ]));
-    const resolvedConfiguredResources = await resolveConfiguredResources(configuredResources, workspaceRoot);
+    const resolvedConfiguredResources = await traceStartupStage("workspace.resolve.configuredResources", () => resolveConfiguredResources(configuredResources, workspaceRoot), {
+        workspaceRoot,
+        configuredResourceCount: configuredResources.length,
+    });
     for (const resource of resolvedConfiguredResources) {
-        await registerAttachedResourceTools(tools, resource.root);
+        await traceStartupStage("workspace.register.attachedResourceTools", () => registerAttachedResourceTools(tools, resource.root), {
+            workspaceRoot,
+            resourceRoot: resource.root,
+        });
     }
     const localResourceRoot = resolveResourcePackageRoot(workspaceRoot);
     const skillCollectionRoots = [
@@ -227,15 +244,24 @@ export async function loadWorkspace(workspaceRoot, options = {}) {
         ...(localResourceRoot ? [path.join(localResourceRoot, "skills")] : []),
         ...resolvedConfiguredResources.map((resource) => path.join(resource.root, "skills")),
     ];
-    const skillRegistry = await registerWorkspaceSkillRegistry(skillCollectionRoots);
+    const skillRegistry = await traceStartupStage("workspace.register.skillRegistry", () => registerWorkspaceSkillRegistry(skillCollectionRoots), {
+        workspaceRoot,
+        skillCollectionRootCount: skillCollectionRoots.length,
+    });
     resolveAgentSkillNames(loaded.agents, skillRegistry, skillCollectionRoots);
     const collectedResources = collectToolSourceRefs(tools, loaded.agents, {
         ...options,
         resources: configuredResources,
     });
     const externalResources = collectedResources.filter((resource) => isExternalSourceLocator(resource));
-    await ensureResourceSources(externalResources, workspaceRoot);
-    await hydrateResourceAndExternalTools(tools, externalResources, workspaceRoot);
+    await traceStartupStage("workspace.ensure.externalResourceSources", () => ensureResourceSources(externalResources, workspaceRoot), {
+        workspaceRoot,
+        externalResourceCount: externalResources.length,
+    });
+    await traceStartupStage("workspace.hydrate.externalTools", () => hydrateResourceAndExternalTools(tools, externalResources, workspaceRoot), {
+        workspaceRoot,
+        externalResourceCount: externalResources.length,
+    });
     validateToolNameConflicts(tools);
     const resources = Array.from(new Set([
         ...(localResourceRoot ? [localResourceRoot] : []),

package/dist/workspace/tool-hydration.js

@@ -72,6 +72,9 @@ function shouldIncludeRemoteMcpTool(filter, toolName) {
     }
     return true;
 }
+function canResolveMcpToolsFromExplicitNamesOnly(filter) {
+    return filter.includeNames.size > 0 && filter.includePatterns.length === 0;
+}
 function normalizeAgentMcpServerUsage(item) {
     const config = asObject(item.config);
     if (!config) {
@@ -235,7 +238,11 @@ export async function hydrateAgentMcpTools(agents, mcpServers, tools) {
                 mcpServers.set(serverId, parsedServer);
             }
             const filter = compileMcpToolFilter(item);
-            const remoteTools = await listRemoteMcpTools(toMcpServerConfig(parsedServer));
+            const remoteTools = canResolveMcpToolsFromExplicitNamesOnly(filter)
+                ? Array.from(filter.includeNames)
+                    .filter((toolName) => shouldIncludeRemoteMcpTool(filter, toolName))
+                    .map((toolName) => ({ name: toolName }))
+                : await listRemoteMcpTools(toMcpServerConfig(parsedServer));
             for (const remoteTool of remoteTools) {
                 if (!shouldIncludeRemoteMcpTool(filter, remoteTool.name)) {
                     continue;

package/package.json

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