@botbotgo/agent-harness 0.0.84 → 0.0.86

package/dist/benchmark/upstream-runtime-ab-benchmark.d.ts

@@ -0,0 +1,51 @@
+export declare const DEFAULT_UPSTREAM_BENCHMARK_PATHS: readonly ["harness", "raw-langchain-v1", "raw-deepagent"];
+export declare const DEFAULT_UPSTREAM_BENCHMARK_WORKLOAD: "tool";
+export type UpstreamBenchmarkPath = (typeof DEFAULT_UPSTREAM_BENCHMARK_PATHS)[number];
+export type UpstreamBenchmarkWorkload = "tool" | "no-tool";
+export type UpstreamBenchmarkRunSummary = {
+    providerLabel: string;
+    model: string;
+    path: UpstreamBenchmarkPath;
+    runNumber: number;
+    status: "completed" | "failed";
+    totalMs: number;
+    firstTokenMs: number | null;
+    outputLength: number;
+    normalizedOutputLength: number;
+    toolCallCount: number;
+    exactOutputMatch: boolean;
+    errorMessage?: string;
+};
+export type UpstreamBenchmarkAggregateSummary = {
+    providerLabel: string;
+    model: string;
+    path: UpstreamBenchmarkPath;
+    repetitions: number;
+    successCount: number;
+    failureCount: number;
+    avgTotalMs: number | null;
+    trimmedAvgTotalMs: number | null;
+    medianTotalMs: number | null;
+    p95TotalMs: number | null;
+    avgFirstTokenMs: number | null;
+    trimmedAvgFirstTokenMs: number | null;
+    medianFirstTokenMs: number | null;
+    p95FirstTokenMs: number | null;
+    avgOutputLength: number | null;
+    avgNormalizedOutputLength: number | null;
+    avgToolCallCount: number | null;
+    exactOutputMatchCount: number;
+};
+export type UpstreamBenchmarkComparison = {
+    baselinePath: UpstreamBenchmarkPath;
+    candidatePath: UpstreamBenchmarkPath;
+    avgTotalMsDelta: number | null;
+    avgTotalMsOverheadPct: number | null;
+    avgFirstTokenMsDelta: number | null;
+    avgFirstTokenMsOverheadPct: number | null;
+};
+export declare function resolveUpstreamBenchmarkPaths(rawValue?: string): readonly UpstreamBenchmarkPath[];
+export declare function resolveUpstreamBenchmarkWorkload(rawValue?: string): UpstreamBenchmarkWorkload;
+export declare function extractLastMatchingToken(output: string, prefixes: readonly string[]): string;
+export declare function aggregateUpstreamBenchmarkRuns(providerLabel: string, model: string, path: UpstreamBenchmarkPath, runs: UpstreamBenchmarkRunSummary[]): UpstreamBenchmarkAggregateSummary;
+export declare function compareUpstreamBenchmarkPaths(baseline: UpstreamBenchmarkAggregateSummary, candidate: UpstreamBenchmarkAggregateSummary): UpstreamBenchmarkComparison;

package/dist/benchmark/upstream-runtime-ab-benchmark.js

@@ -0,0 +1,123 @@
+export const DEFAULT_UPSTREAM_BENCHMARK_PATHS = Object.freeze([
+    "harness",
+    "raw-langchain-v1",
+    "raw-deepagent",
+]);
+export const DEFAULT_UPSTREAM_BENCHMARK_WORKLOAD = "tool";
+function average(values) {
+    return Number((values.reduce((sum, value) => sum + value, 0) / values.length).toFixed(2));
+}
+function median(values) {
+    const sorted = [...values].sort((left, right) => left - right);
+    const middle = Math.floor(sorted.length / 2);
+    if (sorted.length % 2 === 0) {
+        return Number((((sorted[middle - 1] ?? 0) + (sorted[middle] ?? 0)) / 2).toFixed(2));
+    }
+    return Number((sorted[middle] ?? 0).toFixed(2));
+}
+function percentile(values, quantile) {
+    const sorted = [...values].sort((left, right) => left - right);
+    const index = Math.max(0, Math.min(sorted.length - 1, Math.ceil(sorted.length * quantile) - 1));
+    return Number(sorted[index].toFixed(2));
+}
+function averageOrNull(values) {
+    return values.length > 0 ? average(values) : null;
+}
+function medianOrNull(values) {
+    return values.length > 0 ? median(values) : null;
+}
+function percentileOrNull(values, quantile) {
+    return values.length > 0 ? percentile(values, quantile) : null;
+}
+function trimValues(values, trimFraction) {
+    if (values.length <= 2) {
+        return [...values];
+    }
+    const sorted = [...values].sort((left, right) => left - right);
+    const trimCount = Math.min(Math.floor(sorted.length * trimFraction), Math.floor((sorted.length - 1) / 2));
+    return sorted.slice(trimCount, sorted.length - trimCount);
+}
+function trimmedAverageOrNull(values, trimFraction) {
+    return values.length > 0 ? average(trimValues(values, trimFraction)) : null;
+}
+export function resolveUpstreamBenchmarkPaths(rawValue) {
+    if (!rawValue) {
+        return [...DEFAULT_UPSTREAM_BENCHMARK_PATHS];
+    }
+    const parsed = rawValue
+        .split(",")
+        .map((value) => value.trim().toLowerCase())
+        .filter((value) => value === "harness" || value === "raw-langchain-v1" || value === "raw-deepagent");
+    return parsed.length > 0 ? parsed : [...DEFAULT_UPSTREAM_BENCHMARK_PATHS];
+}
+export function resolveUpstreamBenchmarkWorkload(rawValue) {
+    return rawValue?.trim().toLowerCase() === "no-tool" ? "no-tool" : DEFAULT_UPSTREAM_BENCHMARK_WORKLOAD;
+}
+export function extractLastMatchingToken(output, prefixes) {
+    const normalized = output.replace(/\s+/g, " ").trim();
+    let matched = "";
+    for (const prefix of prefixes) {
+        let searchIndex = normalized.indexOf(prefix);
+        while (searchIndex >= 0) {
+            const suffix = normalized.slice(searchIndex);
+            const token = (suffix.split(/\s/)[0] ?? suffix).trim();
+            if (token.length > 0) {
+                matched = token;
+            }
+            searchIndex = normalized.indexOf(prefix, searchIndex + prefix.length);
+        }
+    }
+    return matched || normalized;
+}
+export function aggregateUpstreamBenchmarkRuns(providerLabel, model, path, runs) {
+    const successfulRuns = runs.filter((run) => run.status === "completed");
+    const totalValues = successfulRuns.map((run) => run.totalMs);
+    const firstTokenValues = successfulRuns
+        .map((run) => run.firstTokenMs)
+        .filter((value) => value !== null);
+    return {
+        providerLabel,
+        model,
+        path,
+        repetitions: runs.length,
+        successCount: successfulRuns.length,
+        failureCount: runs.length - successfulRuns.length,
+        avgTotalMs: averageOrNull(totalValues),
+        trimmedAvgTotalMs: trimmedAverageOrNull(totalValues, 0.1),
+        medianTotalMs: medianOrNull(totalValues),
+        p95TotalMs: percentileOrNull(totalValues, 0.95),
+        avgFirstTokenMs: averageOrNull(firstTokenValues),
+        trimmedAvgFirstTokenMs: trimmedAverageOrNull(firstTokenValues, 0.1),
+        medianFirstTokenMs: medianOrNull(firstTokenValues),
+        p95FirstTokenMs: percentileOrNull(firstTokenValues, 0.95),
+        avgOutputLength: averageOrNull(successfulRuns.map((run) => run.outputLength)),
+        avgNormalizedOutputLength: averageOrNull(successfulRuns.map((run) => run.normalizedOutputLength)),
+        avgToolCallCount: averageOrNull(successfulRuns.map((run) => run.toolCallCount)),
+        exactOutputMatchCount: successfulRuns.filter((run) => run.exactOutputMatch).length,
+    };
+}
+function computeOverhead(candidate, baseline) {
+    if (candidate === null || baseline === null) {
+        return { delta: null, pct: null };
+    }
+    const delta = Number((candidate - baseline).toFixed(2));
+    if (baseline === 0) {
+        return { delta, pct: null };
+    }
+    return {
+        delta,
+        pct: Number((((candidate - baseline) / baseline) * 100).toFixed(2)),
+    };
+}
+export function compareUpstreamBenchmarkPaths(baseline, candidate) {
+    const total = computeOverhead(candidate.avgTotalMs, baseline.avgTotalMs);
+    const firstToken = computeOverhead(candidate.avgFirstTokenMs, baseline.avgFirstTokenMs);
+    return {
+        baselinePath: baseline.path,
+        candidatePath: candidate.path,
+        avgTotalMsDelta: total.delta,
+        avgTotalMsOverheadPct: total.pct,
+        avgFirstTokenMsDelta: firstToken.delta,
+        avgFirstTokenMsOverheadPct: firstToken.pct,
+    };
+}

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.83";
+export declare const AGENT_HARNESS_VERSION = "0.0.85";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.83";
+export const AGENT_HARNESS_VERSION = "0.0.85";

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

@@ -15,6 +15,7 @@ export declare class SqlitePersistence implements RuntimePersistence {
     private threadDir;
     private runDir;
     private execute;
+    private executeTransaction;
     private selectOne;
     private selectAll;
     private mapThreadSummary;
@@ -29,6 +30,18 @@ export declare class SqlitePersistence implements RuntimePersistence {
         status: RunState;
         createdAt: string;
     }): Promise<void>;
+    bootstrapRun(input: {
+        threadId: string;
+        agentId: string;
+        runId: string;
+        status: RunState;
+        createdAt: string;
+        executionMode: string;
+        adapterKind?: string;
+        userMessage: TranscriptMessage;
+        runRequest: PersistedRunRequest;
+        createThread: boolean;
+    }): Promise<void>;
     createRun(input: {
         threadId: string;
         runId: string;

package/dist/persistence/sqlite-store.js

@@ -263,6 +263,31 @@ export class SqlitePersistence {
         }
         await client.execute(sql);
     }
+    async executeTransaction(steps) {
+        await this.ensureInitialized();
+        const client = await this.getClient();
+        await client.execute("BEGIN IMMEDIATE");
+        try {
+            for (const step of steps) {
+                if (step.args) {
+                    await client.execute(step.sql, step.args);
+                }
+                else {
+                    await client.execute(step.sql);
+                }
+            }
+            await client.execute("COMMIT");
+        }
+        catch (error) {
+            try {
+                await client.execute("ROLLBACK");
+            }
+            catch {
+                // Ignore rollback failures and preserve the original error.
+            }
+            throw error;
+        }
+    }
     async selectOne(sql, args) {
         await this.ensureInitialized();
         const client = await this.getClient();
@@ -347,6 +372,61 @@ export class SqlitePersistence {
        (thread_id, workspace_id, entry_agent_id, status, latest_run_id, created_at, updated_at)
        VALUES (?, ?, ?, ?, ?, ?, ?)`, [input.threadId, "default", input.agentId, input.status, input.runId, input.createdAt, input.createdAt]);
     }
+    async bootstrapRun(input) {
+        await mkdir(this.threadDir(input.threadId), { recursive: true });
+        await mkdir(path.join(this.runDir(input.threadId, input.runId), "events"), { recursive: true });
+        const steps = [];
+        if (input.createThread) {
+            steps.push({
+                sql: `INSERT OR REPLACE INTO threads
+       (thread_id, workspace_id, entry_agent_id, status, latest_run_id, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`,
+                args: [input.threadId, "default", input.agentId, input.status, input.runId, input.createdAt, input.createdAt],
+            });
+        }
+        steps.push({
+            sql: `INSERT OR REPLACE INTO runs
+       (run_id, thread_id, agent_id, execution_mode, adapter_kind, created_at, updated_at, state, previous_state, state_entered_at, last_transition_at, resumable, checkpoint_ref)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+            args: [
+                input.runId,
+                input.threadId,
+                input.agentId,
+                input.executionMode,
+                input.adapterKind ?? input.executionMode ?? null,
+                input.createdAt,
+                input.createdAt,
+                "running",
+                null,
+                input.createdAt,
+                input.createdAt,
+                0,
+                null,
+            ],
+        }, {
+            sql: `INSERT OR REPLACE INTO run_control
+       (run_id, cancel_requested, cancel_reason, cancel_requested_at, heartbeat_at, worker_id, worker_started_at)
+       VALUES (?, 0, NULL, NULL, NULL, NULL, NULL)`,
+            args: [input.runId],
+        }, {
+            sql: `INSERT INTO thread_messages
+       (thread_id, role, content_json, run_id, created_at)
+       VALUES (?, ?, ?, ?, ?)`,
+            args: [
+                input.threadId,
+                input.userMessage.role,
+                JSON.stringify(input.userMessage.content),
+                input.userMessage.runId,
+                input.userMessage.createdAt,
+            ],
+        }, {
+            sql: `INSERT OR REPLACE INTO run_requests
+       (run_id, thread_id, request_json, saved_at)
+       VALUES (?, ?, ?, ?)`,
+            args: [input.runId, input.threadId, JSON.stringify(input.runRequest), input.runRequest.savedAt],
+        });
+        await this.executeTransaction(steps);
+    }
     async createRun(input) {
         await mkdir(path.join(this.runDir(input.threadId, input.runId), "events"), { recursive: true });
         await this.execute(`INSERT OR REPLACE INTO runs

package/dist/persistence/types.d.ts

@@ -75,6 +75,18 @@ export type ApprovalFilter = {
 };
 export interface RuntimePersistence {
     initialize(): Promise<void>;
+    bootstrapRun?(input: {
+        threadId: string;
+        agentId: string;
+        runId: string;
+        status: RunState;
+        createdAt: string;
+        executionMode: string;
+        adapterKind?: string;
+        userMessage: TranscriptMessage;
+        runRequest: PersistedRunRequest;
+        createThread: boolean;
+    }): Promise<void>;
     createThread(input: {
         threadId: string;
         agentId: string;

package/dist/runtime/agent-runtime-adapter.d.ts

@@ -35,7 +35,6 @@ export declare class AgentRuntimeAdapter {
     private materializeModelStream;
     private createModelFallbackRunnable;
     private applyStrictToolJsonInstruction;
-    private synthesizeDeepAgentAnswer;
     private resolveModel;
     private buildToolNameMapping;
     private buildAgentMessages;

package/dist/runtime/agent-runtime-adapter.js

@@ -1,6 +1,4 @@
 import path from "node:path";
-import { existsSync, statSync } from "node:fs";
-import { cp, mkdir, rm } from "node:fs/promises";
 import { Command, MemorySaver } from "@langchain/langgraph";
 import { tool as createLangChainTool } from "@langchain/core/tools";
 import { HumanMessage, ToolMessage } from "@langchain/core/messages";
@@ -85,49 +83,12 @@ export function relativizeDeepAgentSkillSourcePaths(workspaceRoot, skillPaths) {
         return relative.split(path.sep).join("/");
     });
 }
-function isDeepAgentSkillDirectory(sourcePath) {
-    return existsSync(sourcePath) && statSync(sourcePath).isDirectory() && existsSync(path.join(sourcePath, "SKILL.md"));
-}
-function toWorkspaceRelativePath(workspaceRoot, targetPath) {
-    if (!workspaceRoot) {
-        return targetPath;
-    }
-    const relative = path.relative(workspaceRoot, targetPath);
-    if (!relative || relative.startsWith("..")) {
-        return targetPath;
-    }
-    return relative.split(path.sep).join("/");
-}
 export async function materializeDeepAgentSkillSourcePaths(options) {
-    const { workspaceRoot, runRoot, ownerId, skillPaths } = options;
+    const { workspaceRoot, skillPaths } = options;
     if (!skillPaths) {
         return skillPaths;
     }
-    const materialized = relativizeDeepAgentSkillSourcePaths(workspaceRoot, skillPaths) ?? skillPaths;
-    if (!workspaceRoot || !runRoot) {
-        return materialized;
-    }
-    const sourceRoot = path.join(runRoot, "deepagent-skill-sources", ownerId);
-    let wroteSyntheticSource = false;
-    const resolvedSources = [];
-    for (const [index, sourcePath] of materialized.entries()) {
-        const absolutePath = path.isAbsolute(sourcePath) ? sourcePath : path.resolve(workspaceRoot, sourcePath);
-        if (!isDeepAgentSkillDirectory(absolutePath)) {
-            resolvedSources.push(sourcePath);
-            continue;
-        }
-        if (!wroteSyntheticSource) {
-            await rm(sourceRoot, { recursive: true, force: true });
-            await mkdir(sourceRoot, { recursive: true });
-            wroteSyntheticSource = true;
-        }
-        const skillDirectoryName = path.basename(absolutePath);
-        const syntheticSourcePath = path.join(sourceRoot, `${String(index + 1).padStart(3, "0")}-${skillDirectoryName}`);
-        await mkdir(syntheticSourcePath, { recursive: true });
-        await cp(absolutePath, path.join(syntheticSourcePath, skillDirectoryName), { recursive: true });
-        resolvedSources.push(toWorkspaceRelativePath(workspaceRoot, syntheticSourcePath));
-    }
-    return resolvedSources;
+    return relativizeDeepAgentSkillSourcePaths(workspaceRoot, skillPaths) ?? skillPaths;
 }
 function buildAuthOmittingFetch(baseFetch = fetch) {
     return async (input, init) => {
@@ -673,31 +634,6 @@ export class AgentRuntimeAdapter {
         }
         return binding;
     }
-    async synthesizeDeepAgentAnswer(binding, input, result) {
-        const params = getBindingDeepAgentParams(binding);
-        if (!params) {
-            return "";
-        }
-        const toolContext = extractToolFallbackContext(result);
-        if (!toolContext) {
-            return "";
-        }
-        const model = (await this.resolveModel(params.model));
-        if (!model?.invoke) {
-            return "";
-        }
-        const synthesized = await this.withTimeout(() => model.invoke([
-            {
-                role: "system",
-                content: "The previous agent run completed tool work but did not produce a final user-facing answer. Write the final answer now using the tool results provided. Do not expose internal state, tools, or reasoning.",
-            },
-            {
-                role: "user",
-                content: `Original user request:\n${extractMessageText(input)}\n\nTool results:\n${toolContext}`,
-            },
-        ]), this.resolveBindingTimeout(binding), "deepagent synthesis invoke", "invoke");
-        return sanitizeVisibleText(extractVisibleOutput(synthesized));
-    }
     async resolveModel(model) {
         const cacheKey = this.getModelCacheKey(model);
         const cached = this.modelCache.get(cacheKey);
@@ -1166,7 +1102,7 @@ export class AgentRuntimeAdapter {
         if (!isDeepAgentBinding(binding)) {
             return [];
         }
-        return this.resolveAutomaticSummarizationMiddleware(binding);
+        return [];
     }
     async resolveMiddleware(binding, interruptOn) {
         const declarativeMiddleware = await resolveDeclaredMiddleware(getBindingMiddlewareConfigs(binding), {
@@ -1469,19 +1405,10 @@ export class AgentRuntimeAdapter {
         const visibleOutput = extractedOutput && !isLikelyToolArgsObject(tryParseJson(extractedOutput)) ? extractedOutput : "";
         const emptyAssistantMessageFailure = extractEmptyAssistantMessageFailure(result);
         const toolFallback = extractToolFallbackContext(result);
-        let synthesizedOutput = "";
-        try {
-            synthesizedOutput = await this.synthesizeDeepAgentAnswer(binding, input, result);
-        }
-        catch (error) {
-            if (!(error instanceof RuntimeOperationTimeoutError) || !toolFallback) {
-                throw error;
-            }
-        }
-        if (!visibleOutput && !synthesizedOutput && !toolFallback && emptyAssistantMessageFailure) {
+        if (!visibleOutput && !toolFallback && emptyAssistantMessageFailure) {
             throw new Error(emptyAssistantMessageFailure);
         }
-        const output = visibleOutput || synthesizedOutput || toolFallback || JSON.stringify(result, null, 2);
+        const output = visibleOutput || toolFallback || JSON.stringify(result, null, 2);
         const finalMessageText = sanitizeVisibleText(output);
         const outputContent = extractOutputContent(result);
         const contentBlocks = extractContentBlocks(result);

package/dist/runtime/harness.d.ts

@@ -5,6 +5,8 @@ import type { RequirementAssessmentOptions } from "./skill-requirements.js";
 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;
     private readonly policyEngine;
@@ -27,6 +29,7 @@ export declare class AgentHarnessRuntime {
     private readonly healthMonitor;
     private readonly recoveryConfig;
     private readonly concurrencyConfig;
+    private readonly backgroundTasks;
     private readonly workerId;
     private activeRunSlots;
     private pendingRunInsertionOrder;
@@ -38,6 +41,7 @@ export declare class AgentHarnessRuntime {
     private listHostBindings;
     private defaultRunRoot;
     private heuristicRoute;
+    private getDefaultHostAgentId;
     private buildRoutingInput;
     private resolveSelectedAgentId;
     private resolveStore;
@@ -82,6 +86,7 @@ export declare class AgentHarnessRuntime {
         threadId?: string;
     }): Promise<string>;
     private emit;
+    private trackBackgroundTask;
     private ensureThreadStarted;
     private loadPriorHistory;
     private loadRunInput;
@@ -99,6 +104,7 @@ export declare class AgentHarnessRuntime {
     private finalizeContinuedRun;
     private emitOutputDeltaAndCreateItem;
     private createContentBlocksItem;
+    private createToolResultKey;
     private emitRunCreated;
     private setRunStateAndEmit;
     private requestApprovalAndEmit;

package/dist/runtime/harness.js

@@ -22,6 +22,14 @@ import { describeWorkspaceInventory, listAgentSkills as listWorkspaceAgentSkills
 export class AgentHarnessRuntime {
     workspace;
     runtimeAdapterOptions;
+    static DEFAULT_HOST_AGENT_ID = "orchestra";
+    static BACKGROUND_EVENT_TYPES = new Set([
+        "run.created",
+        "run.queued",
+        "run.dequeued",
+        "output.delta",
+        "reasoning.delta",
+    ]);
     eventBus = new EventBus();
     persistence;
     policyEngine = new PolicyEngine();
@@ -44,6 +52,7 @@ export class AgentHarnessRuntime {
     healthMonitor;
     recoveryConfig;
     concurrencyConfig;
+    backgroundTasks = new Set();
     workerId = `worker-${createPersistentId()}`;
     activeRunSlots = 0;
     pendingRunInsertionOrder = 0;
@@ -76,6 +85,13 @@ export class AgentHarnessRuntime {
         const { primaryBinding, secondaryBinding } = inferRoutingBindings(this.workspace);
         return heuristicRoute(extractMessageText(input), primaryBinding, secondaryBinding);
     }
+    getDefaultHostAgentId() {
+        const orchestraBinding = this.workspace.bindings.get(AgentHarnessRuntime.DEFAULT_HOST_AGENT_ID);
+        if (orchestraBinding && orchestraBinding.harnessRuntime.hostFacing !== false) {
+            return orchestraBinding.agent.id;
+        }
+        return this.heuristicRoute("");
+    }
     async buildRoutingInput(input, threadId) {
         const inputText = extractMessageText(input);
         if (!threadId) {
@@ -107,7 +123,7 @@ export class AgentHarnessRuntime {
                     return thread.agentId;
                 }
             }
-            return this.routeAgent(input, { threadId });
+            return this.getDefaultHostAgentId();
         }
         return requestedAgentId;
     }
@@ -404,41 +420,72 @@ export class AgentHarnessRuntime {
     }
     async emit(threadId, runId, sequence, eventType, payload, source = "runtime") {
         const event = createHarnessEvent(threadId, runId, sequence, eventType, payload, source);
-        await this.persistence.appendEvent(event);
-        this.eventBus.publish(event);
-        if (this.threadMemorySync.shouldHandle(event)) {
-            await this.threadMemorySync.handleEvent(event);
+        if (AgentHarnessRuntime.BACKGROUND_EVENT_TYPES.has(event.eventType)) {
+            this.trackBackgroundTask(this.persistence.appendEvent(event).catch(() => {
+                // Fail open for telemetry-style event persistence.
+            }));
+        }
+        else {
+            await this.persistence.appendEvent(event);
         }
+        this.eventBus.publish(event);
         return event;
     }
-    async ensureThreadStarted(selectedAgentId, binding, input, existingThreadId) {
+    trackBackgroundTask(task) {
+        this.backgroundTasks.add(task);
+        void task.finally(() => {
+            this.backgroundTasks.delete(task);
+        });
+    }
+    async ensureThreadStarted(selectedAgentId, binding, input, runRequest, existingThreadId) {
         const threadId = existingThreadId ?? createPersistentId();
         const runId = createPersistentId();
         const createdAt = new Date().toISOString();
-        if (!existingThreadId) {
-            await this.persistence.createThread({
+        const isNewThread = !existingThreadId;
+        const userMessage = {
+            role: "user",
+            content: normalizeMessageContent(input),
+            runId,
+            createdAt,
+        };
+        if (typeof this.persistence.bootstrapRun === "function") {
+            await this.persistence.bootstrapRun({
                 threadId,
-                agentId: selectedAgentId,
+                agentId: binding.agent.id,
                 runId,
                 status: "running",
                 createdAt,
+                executionMode: getBindingAdapterKind(binding),
+                adapterKind: getBindingAdapterKind(binding),
+                userMessage,
+                runRequest,
+                createThread: isNewThread,
             });
         }
-        await this.persistence.appendThreadMessage(threadId, {
-            role: "user",
-            content: normalizeMessageContent(input),
-            runId,
-            createdAt,
-        });
-        await this.persistence.createRun({
-            threadId,
-            runId,
-            agentId: binding.agent.id,
-            executionMode: getBindingAdapterKind(binding),
-            adapterKind: getBindingAdapterKind(binding),
-            createdAt,
-        });
-        return { threadId, runId, createdAt };
+        else {
+            if (isNewThread) {
+                await this.persistence.createThread({
+                    threadId,
+                    agentId: selectedAgentId,
+                    runId,
+                    status: "running",
+                    createdAt,
+                });
+            }
+            await Promise.all([
+                this.persistence.appendThreadMessage(threadId, userMessage),
+                this.persistence.createRun({
+                    threadId,
+                    runId,
+                    agentId: binding.agent.id,
+                    executionMode: getBindingAdapterKind(binding),
+                    adapterKind: getBindingAdapterKind(binding),
+                    createdAt,
+                }),
+                this.persistence.saveRunRequest(threadId, runId, runRequest),
+            ]);
+        }
+        return { threadId, runId, createdAt, isNewThread };
     }
     async loadPriorHistory(threadId, runId) {
         const history = await this.persistence.listThreadMessages(threadId);
@@ -500,11 +547,11 @@ export class AgentHarnessRuntime {
             output: reason ? `cancelled: ${reason}` : "cancelled",
         };
     }
-    async invokeWithHistory(binding, input, threadId, runId, resumePayload, options = {}) {
-        const priorHistory = await this.loadPriorHistory(threadId, runId);
+    async invokeWithHistory(binding, input, threadId, runId, resumePayload, priorHistory, options = {}) {
+        const history = priorHistory ?? await this.loadPriorHistory(threadId, runId);
         const startedAt = Date.now();
         try {
-            const result = await this.runtimeAdapter.invoke(binding, input, threadId, runId, resumePayload, priorHistory, options);
+            const result = await this.runtimeAdapter.invoke(binding, input, threadId, runId, resumePayload, history, options);
             this.healthMonitor.recordLlmSuccess(Date.now() - startedAt);
             return result;
         }
@@ -603,7 +650,7 @@ export class AgentHarnessRuntime {
             });
         }
         try {
-            const actual = await this.invokeWithHistory(binding, input, threadId, runId, undefined, {
+            const actual = await this.invokeWithHistory(binding, input, threadId, runId, undefined, options.priorHistory, {
                 context: options.context,
                 state: options.state,
                 files: options.files,
@@ -683,6 +730,16 @@ export class AgentHarnessRuntime {
             contentBlocks,
         };
     }
+    createToolResultKey(toolName, output, isError) {
+        let serializedOutput = "";
+        try {
+            serializedOutput = JSON.stringify(output);
+        }
+        catch {
+            serializedOutput = String(output);
+        }
+        return JSON.stringify([toolName, serializedOutput, isError === true]);
+    }
     async emitRunCreated(threadId, runId, payload) {
         return this.emit(threadId, runId, 1, "run.created", payload);
     }
@@ -757,22 +814,29 @@ export class AgentHarnessRuntime {
         await listener(value);
     }
     async acquireRunSlot(threadId, runId, activeState = "running", priority = 0) {
-        if (threadId && runId) {
-            await this.persistence.enqueueRun({ threadId, runId, priority });
-        }
         let stopHeartbeat = () => undefined;
-        const beginLease = async () => {
+        const beginLease = async (mode) => {
             if (!threadId || !runId) {
                 return;
             }
             const claimedAt = new Date().toISOString();
-            await this.persistence.claimQueuedRun({
-                threadId,
-                runId,
-                workerId: this.workerId,
-                claimedAt,
-                leaseExpiresAt: new Date(Date.now() + this.concurrencyConfig.leaseMs).toISOString(),
-            });
+            if (mode === "queue-claim") {
+                await this.persistence.claimQueuedRun({
+                    threadId,
+                    runId,
+                    workerId: this.workerId,
+                    claimedAt,
+                    leaseExpiresAt: new Date(Date.now() + this.concurrencyConfig.leaseMs).toISOString(),
+                });
+            }
+            else {
+                await this.persistence.renewRunLease({
+                    runId,
+                    workerId: this.workerId,
+                    heartbeatAt: claimedAt,
+                    leaseExpiresAt: new Date(Date.now() + this.concurrencyConfig.leaseMs).toISOString(),
+                });
+            }
             if (this.concurrencyConfig.heartbeatIntervalMs <= 0) {
                 return;
             }
@@ -797,14 +861,19 @@ export class AgentHarnessRuntime {
         };
         const maxConcurrentRuns = this.concurrencyConfig.maxConcurrentRuns;
         if (!maxConcurrentRuns) {
-            await beginLease();
+            await beginLease("direct-heartbeat");
             return async () => {
                 await releaseLease();
             };
         }
-        if (this.activeRunSlots < maxConcurrentRuns) {
+        const canActivateImmediately = this.activeRunSlots < maxConcurrentRuns;
+        const useDirectHeartbeatFastPath = canActivateImmediately && maxConcurrentRuns > 1;
+        if (canActivateImmediately) {
             this.activeRunSlots += 1;
-            await beginLease();
+            if (threadId && runId && !useDirectHeartbeatFastPath) {
+                await this.persistence.enqueueRun({ threadId, runId, priority });
+            }
+            await beginLease(useDirectHeartbeatFastPath ? "direct-heartbeat" : "queue-claim");
             let released = false;
             return async () => {
                 if (released) {
@@ -833,11 +902,12 @@ export class AgentHarnessRuntime {
                 await this.setRunStateAndEmit(threadId, runId, 5, activeState, {
                     previousState: "queued",
                 });
-                await beginLease();
+                await beginLease("queue-claim");
             }
             return "activate";
         };
         if (threadId && runId) {
+            await this.persistence.enqueueRun({ threadId, runId, priority });
             const slotAcquisition = new Promise((resolve, reject) => {
                 const displacedEntries = this.enqueuePendingRunSlot({
                     threadId,
@@ -994,16 +1064,18 @@ export class AgentHarnessRuntime {
         if (!policyDecision.allowed) {
             throw new Error(`Policy evaluation blocked agent ${selectedAgentId}: ${policyDecision.reasons.join(", ")}`);
         }
-        const { threadId, runId } = await this.ensureThreadStarted(selectedAgentId, binding, options.input, options.threadId);
         const priority = this.normalizeRunPriority(options.priority);
-        await this.persistence.saveRunRequest(threadId, runId, this.buildPersistedRunRequest(options.input, invocation, priority));
-        await this.emitRunCreated(threadId, runId, {
+        const runRequest = this.buildPersistedRunRequest(options.input, invocation, priority);
+        const { threadId, runId, isNewThread } = await this.ensureThreadStarted(selectedAgentId, binding, options.input, runRequest, options.threadId);
+        const runCreatedEventPromise = this.emitRunCreated(threadId, runId, {
             agentId: binding.agent.id,
             requestedAgentId: options.agentId ?? AUTO_AGENT_ID,
             selectedAgentId,
             executionMode: getBindingAdapterKind(binding),
         });
-        const releaseRunSlot = await this.acquireRunSlot(threadId, runId, "running", priority);
+        const releaseRunSlotPromise = this.acquireRunSlot(threadId, runId, "running", priority);
+        await runCreatedEventPromise;
+        const releaseRunSlot = await releaseRunSlotPromise;
         try {
             return await this.executeQueuedRun(binding, options.input, threadId, runId, selectedAgentId, {
                 context: invocation.context,
@@ -1012,6 +1084,7 @@ export class AgentHarnessRuntime {
                 previousState: "running",
                 stateSequence: 6,
                 approvalSequence: 7,
+                priorHistory: isNewThread ? [] : undefined,
             });
         }
         finally {
@@ -1037,22 +1110,30 @@ export class AgentHarnessRuntime {
         }
         let emitted = false;
         let streamActivityObserved = false;
-        const { threadId, runId } = await this.ensureThreadStarted(selectedAgentId, binding, options.input, options.threadId);
         const priority = this.normalizeRunPriority(options.priority);
-        await this.persistence.saveRunRequest(threadId, runId, this.buildPersistedRunRequest(options.input, invocation, priority));
-        yield { type: "event", event: await this.emitRunCreated(threadId, runId, {
-                agentId: selectedAgentId,
-                requestedAgentId: options.agentId ?? AUTO_AGENT_ID,
-                selectedAgentId,
-                input: options.input,
-                state: "running",
-            }) };
-        const releaseRunSlot = await this.acquireRunSlot(threadId, runId, "running", priority);
+        const runRequest = this.buildPersistedRunRequest(options.input, invocation, priority);
+        const { threadId, runId, isNewThread } = await this.ensureThreadStarted(selectedAgentId, binding, options.input, runRequest, options.threadId);
+        const priorHistoryPromise = Promise.resolve(isNewThread ? [] : undefined).then((historyHint) => historyHint ?? this.loadPriorHistory(threadId, runId));
+        const runCreatedEventPromise = this.emitRunCreated(threadId, runId, {
+            agentId: selectedAgentId,
+            requestedAgentId: options.agentId ?? AUTO_AGENT_ID,
+            selectedAgentId,
+            input: options.input,
+            state: "running",
+        });
+        yield { type: "event", event: await runCreatedEventPromise };
+        const releaseRunSlotPromise = this.acquireRunSlot(threadId, runId, "running", priority);
+        let releaseRunSlot = async () => undefined;
         try {
             try {
-                const priorHistory = await this.loadPriorHistory(threadId, runId);
+                const [priorHistory, acquiredReleaseRunSlot] = await Promise.all([
+                    priorHistoryPromise,
+                    releaseRunSlotPromise,
+                ]).then(([loadedPriorHistory, resolvedReleaseRunSlot]) => [loadedPriorHistory, resolvedReleaseRunSlot]);
+                releaseRunSlot = acquiredReleaseRunSlot;
                 let assistantOutput = "";
                 const toolErrors = [];
+                let lastToolResultKey = null;
                 for await (const chunk of this.runtimeAdapter.stream(binding, options.input, threadId, priorHistory, {
                     context: invocation.context,
                     state: invocation.state,
@@ -1120,6 +1201,11 @@ export class AgentHarnessRuntime {
                             continue;
                         }
                         if (normalizedChunk.kind === "tool-result") {
+                            const toolResultKey = this.createToolResultKey(normalizedChunk.toolName, normalizedChunk.output, normalizedChunk.isError);
+                            if (toolResultKey === lastToolResultKey) {
+                                continue;
+                            }
+                            lastToolResultKey = toolResultKey;
                             if (normalizedChunk.isError) {
                                 toolErrors.push(renderToolFailure(normalizedChunk.toolName, normalizedChunk.output));
                             }
@@ -1425,6 +1511,7 @@ export class AgentHarnessRuntime {
         await this.checkpointMaintenance?.stop();
         await this.runtimeRecordMaintenance?.stop();
         this.unregisterThreadMemorySync();
+        await Promise.allSettled(Array.from(this.backgroundTasks));
         await this.threadMemorySync.close();
     }
     async stop() {

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

@@ -79,7 +79,6 @@ export class ThreadMemorySync {
             this.pending.delete(task);
         });
         this.pending.add(task);
-        await task;
     }
     async syncThread(threadId) {
         const thread = await this.persistence.getSession(threadId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.84",
+  "version": "0.0.86",
   "description": "Workspace runtime for multi-agent applications",
   "type": "module",
   "packageManager": "npm@10.9.2",
@@ -53,7 +53,8 @@
   "scripts": {
     "build": "rm -rf dist tsconfig.tsbuildinfo && tsc -p tsconfig.json && cp -R config dist/",
     "check": "tsc -p tsconfig.json --noEmit",
-    "test": "vitest run test/hello-file.test.ts test/public-api.test.ts test/runtime-health.test.ts test/memory-runtime.test.ts test/sqlite-persistence.test.ts test/runtime-queue-lease.test.ts test/runtime-cancel.test.ts test/runtime-record-maintenance.test.ts test/resource-optional-provider.test.ts test/resource-isolation.test.ts test/stock-research-app-load-harness.test.ts test/stock-research-app-run.test.ts test/stock-research-app-config.test.ts test/release-workflow.test.ts test/release-version.test.ts test/gitignore.test.ts test/package-lock.test.ts test/readme.test.ts test/product-boundary-docs.test.ts test/long-term-memory-docs.test.ts test/local-docs-persistence-inventory.test.ts test/docs-site.test.ts test/runtime-adapter-regressions.test.ts test/runtime-capabilities.test.ts test/runtime-recovery.test.ts test/tool-extension-gaps.test.ts test/checkpoint-maintenance.test.ts test/llamaindex-dependency-compat.test.ts test/skill-standard.test.ts test/routing-config.test.ts test/workspace-compat-regressions.test.ts test/upstream-compat-regressions.test.ts test/yaml-format.test.ts test/config-secrets.test.ts test/init-command.test.ts test/coding-agent-guide.test.ts",
+    "test": "vitest run test/hello-file.test.ts test/public-api.test.ts test/runtime-health.test.ts test/memory-runtime.test.ts test/sqlite-persistence.test.ts test/runtime-queue-lease.test.ts test/runtime-cancel.test.ts test/runtime-record-maintenance.test.ts test/resource-optional-provider.test.ts test/resource-isolation.test.ts test/stock-research-app-load-harness.test.ts test/stock-research-app-run.test.ts test/stock-research-app-config.test.ts test/release-workflow.test.ts test/release-version.test.ts test/gitignore.test.ts test/package-lock.test.ts test/readme.test.ts test/product-boundary-docs.test.ts test/long-term-memory-docs.test.ts test/local-docs-persistence-inventory.test.ts test/docs-site.test.ts test/runtime-adapter-regressions.test.ts test/runtime-capabilities.test.ts test/runtime-recovery.test.ts test/tool-extension-gaps.test.ts test/checkpoint-maintenance.test.ts test/llamaindex-dependency-compat.test.ts test/skill-standard.test.ts test/routing-config.test.ts test/workspace-compat-regressions.test.ts test/upstream-compat-regressions.test.ts test/upstream-runtime-ab-benchmark.test.ts test/yaml-format.test.ts test/config-secrets.test.ts test/init-command.test.ts test/coding-agent-guide.test.ts",
+    "test:upstream-ab-real": "vitest run test/upstream-runtime-ab-real.test.ts",
     "test:real-providers": "vitest run test/real-provider-harness.test.ts",
     "release:prepare": "npm version patch --no-git-tag-version && node ./scripts/sync-example-version.mjs",
     "release:pack": "npm pack --dry-run",