@botbotgo/agent-harness 0.0.96 → 0.0.98

package/dist/runtime/harness/index.js

@@ -0,0 +1,16 @@
+export * from "./events/event-bus.js";
+export * from "./events/event-sink.js";
+export * from "./events/events.js";
+export * from "./system/health-monitor.js";
+export * from "./run/helpers.js";
+export * from "./system/inventory.js";
+export * from "./system/policy-engine.js";
+export * from "./run/resources.js";
+export * from "./run/resume.js";
+export * from "./run/routing.js";
+export * from "./run/run-lifecycle.js";
+export * from "./run/run-queue.js";
+export * from "./system/skill-requirements.js";
+export * from "./system/store.js";
+export * from "./events/streaming.js";
+export * from "./system/thread-memory-sync.js";

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

@@ -0,0 +1,33 @@
+import type { ApprovalRecord, HarnessEvent, InternalApprovalRecord, InvocationEnvelope, RunListeners, RunOptions, RunResult, RunStartOptions, MessageContent } from "../../../contracts/types.js";
+export declare function toPublicApprovalRecord(approval: InternalApprovalRecord): ApprovalRecord;
+export declare function normalizeInvocationEnvelope(options: RunStartOptions): {
+    context?: Record<string, unknown>;
+    state?: Record<string, unknown>;
+    files?: Record<string, unknown>;
+    invocation?: InvocationEnvelope;
+};
+export declare function isTerminalRunState(state: RunResult["state"]): boolean;
+export declare function buildPersistedRunRequest(input: MessageContent, invocation: {
+    context?: Record<string, unknown>;
+    state?: Record<string, unknown>;
+    files?: Record<string, unknown>;
+    invocation?: InvocationEnvelope;
+}, priority?: number): {
+    input: MessageContent;
+    priority?: number;
+    invocation?: InvocationEnvelope;
+    savedAt: string;
+};
+export declare function normalizeRunPriority(priority?: number): number;
+export declare function resolveRunListeners(options: RunOptions): RunListeners | undefined;
+export declare function mergeRunResultOutput(result: RunResult, streamedOutput: string): RunResult;
+export declare function createFallbackRunResultFromLatestEvent(input: {
+    latestEvent: HarnessEvent;
+    currentState: RunResult["state"];
+    latestRunId: string;
+    entryAgentId: string;
+    latestAgentId?: string;
+    approvalId?: string;
+    pendingActionId?: string;
+    output: string;
+}): RunResult;

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

@@ -0,0 +1,74 @@
+import { normalizeMessageContent } from "../../../utils/message-content.js";
+export function toPublicApprovalRecord(approval) {
+    const { toolCallId: _toolCallId, checkpointRef: _checkpointRef, eventRefs: _eventRefs, ...publicApproval } = approval;
+    return publicApproval;
+}
+export function normalizeInvocationEnvelope(options) {
+    const invocation = options.invocation;
+    return {
+        context: invocation?.context,
+        state: invocation?.inputs,
+        files: invocation?.attachments,
+        invocation,
+    };
+}
+export function isTerminalRunState(state) {
+    return state === "completed" || state === "failed";
+}
+export function buildPersistedRunRequest(input, invocation, priority) {
+    const envelope = invocation.invocation ?? {
+        ...(invocation.context ? { context: invocation.context } : {}),
+        ...(invocation.state ? { inputs: invocation.state } : {}),
+        ...(invocation.files ? { attachments: invocation.files } : {}),
+    };
+    return {
+        input: normalizeMessageContent(input),
+        priority: Number.isFinite(priority) ? Math.trunc(priority) : undefined,
+        invocation: envelope && Object.keys(envelope).length > 0
+            ? {
+                ...(envelope.context ? { context: envelope.context } : {}),
+                ...(envelope.inputs ? { inputs: envelope.inputs } : {}),
+                ...(envelope.attachments ? { attachments: envelope.attachments } : {}),
+                ...(envelope.capabilities ? { capabilities: envelope.capabilities } : {}),
+            }
+            : undefined,
+        savedAt: new Date().toISOString(),
+    };
+}
+export function normalizeRunPriority(priority) {
+    if (!Number.isFinite(priority)) {
+        return 0;
+    }
+    return Math.trunc(priority);
+}
+export function resolveRunListeners(options) {
+    const runtimeListeners = "runtimeListeners" in options ? options.runtimeListeners : undefined;
+    const frontendListeners = "frontendListeners" in options ? options.frontendListeners : undefined;
+    const listeners = options.listeners;
+    if (!listeners && !runtimeListeners && !frontendListeners) {
+        return undefined;
+    }
+    return {
+        ...(runtimeListeners ?? {}),
+        ...(frontendListeners ?? {}),
+        ...(listeners ?? {}),
+    };
+}
+export function mergeRunResultOutput(result, streamedOutput) {
+    return {
+        ...result,
+        output: result.output || streamedOutput,
+        finalMessageText: result.finalMessageText ?? result.output ?? streamedOutput,
+    };
+}
+export function createFallbackRunResultFromLatestEvent(input) {
+    return {
+        threadId: input.latestEvent.threadId,
+        runId: input.latestRunId,
+        agentId: input.latestAgentId ?? input.entryAgentId,
+        state: input.currentState,
+        output: input.output,
+        approvalId: input.approvalId,
+        pendingActionId: input.pendingActionId,
+    };
+}

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

@@ -0,0 +1,7 @@
+import type { CompiledAgentBinding, RuntimeAdapterOptions, WorkspaceBundle } from "../../../contracts/types.js";
+import type { StoreLike } from "../system/store.js";
+export declare function resolveStoreFromConfig(stores: Map<string, StoreLike>, storeConfig: Record<string, unknown> | undefined, runRoot: string): StoreLike | undefined;
+export declare function resolveStore(stores: Map<string, StoreLike>, defaultStore: StoreLike, defaultRunRoot: string, getBindingStoreConfig: (binding?: CompiledAgentBinding) => Record<string, unknown> | undefined, binding?: CompiledAgentBinding): StoreLike;
+export declare function resolveEmbeddingModel(workspace: WorkspaceBundle, embeddingModels: Map<string, unknown>, embeddingModelRef: string | undefined, runtimeAdapterOptions: RuntimeAdapterOptions): Promise<unknown>;
+export declare function resolveVectorStore(workspace: WorkspaceBundle, vectorStores: Map<string, unknown>, vectorStoreRef: string | undefined, runtimeAdapterOptions: RuntimeAdapterOptions): Promise<unknown>;
+export declare function resolveCheckpointer(checkpointers: Map<string, unknown>, binding: CompiledAgentBinding): unknown;

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

@@ -0,0 +1,58 @@
+import { createCheckpointerForConfig, createStoreForConfig } from "../../support/runtime-factories.js";
+import { resolveCompiledEmbeddingModel, resolveCompiledEmbeddingModelRef } from "../../support/embedding-models.js";
+import { resolveCompiledVectorStore, resolveCompiledVectorStoreRef } from "../../support/vector-stores.js";
+export function resolveStoreFromConfig(stores, storeConfig, runRoot) {
+    const cacheKey = storeConfig ? JSON.stringify(storeConfig) : undefined;
+    if (!storeConfig || !cacheKey) {
+        return undefined;
+    }
+    const existing = stores.get(cacheKey);
+    if (existing) {
+        return existing;
+    }
+    const created = createStoreForConfig(storeConfig, runRoot);
+    stores.set(cacheKey, created);
+    return created;
+}
+export function resolveStore(stores, defaultStore, defaultRunRoot, getBindingStoreConfig, binding) {
+    const storeConfig = getBindingStoreConfig(binding);
+    return resolveStoreFromConfig(stores, storeConfig, binding?.harnessRuntime.runRoot ?? defaultRunRoot) ?? defaultStore;
+}
+export async function resolveEmbeddingModel(workspace, embeddingModels, embeddingModelRef, runtimeAdapterOptions) {
+    const compiled = resolveCompiledEmbeddingModelRef(workspace, embeddingModelRef);
+    const existing = embeddingModels.get(compiled.id);
+    if (existing) {
+        return existing;
+    }
+    const resolved = await resolveCompiledEmbeddingModel(compiled, runtimeAdapterOptions.embeddingModelResolver);
+    embeddingModels.set(compiled.id, resolved);
+    return resolved;
+}
+export async function resolveVectorStore(workspace, vectorStores, vectorStoreRef, runtimeAdapterOptions) {
+    const compiled = resolveCompiledVectorStoreRef(workspace, vectorStoreRef);
+    const existing = vectorStores.get(compiled.id);
+    if (existing) {
+        return existing;
+    }
+    const resolved = await resolveCompiledVectorStore(workspace, compiled, {
+        embeddingModelResolver: runtimeAdapterOptions.embeddingModelResolver,
+        vectorStoreResolver: runtimeAdapterOptions.vectorStoreResolver,
+    });
+    vectorStores.set(compiled.id, resolved);
+    return resolved;
+}
+export function resolveCheckpointer(checkpointers, binding) {
+    const key = `${binding.harnessRuntime.runRoot}:${JSON.stringify(binding.harnessRuntime.checkpointer ?? { kind: "FileCheckpointer", path: "checkpoints.json" })}`;
+    const existing = checkpointers.get(key);
+    if (existing) {
+        return existing;
+    }
+    const resolvedConfig = binding.harnessRuntime.checkpointer ?? { kind: "FileCheckpointer", path: "checkpoints.json" };
+    if (typeof resolvedConfig === "boolean") {
+        checkpointers.set(key, resolvedConfig);
+        return resolvedConfig;
+    }
+    const saver = createCheckpointerForConfig(resolvedConfig, binding.harnessRuntime.runRoot);
+    checkpointers.set(key, saver);
+    return saver;
+}

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

@@ -0,0 +1,6 @@
+import type { InternalApprovalRecord, ResumeOptions, ThreadSummary, WorkspaceBundle } from "../../../contracts/types.js";
+import type { RuntimePersistence } from "../../../persistence/types.js";
+type ResumePersistence = Pick<RuntimePersistence, "getApproval" | "getRunApprovals">;
+export declare function resolveApprovalRecord(persistence: ResumePersistence, options: ResumeOptions, thread: ThreadSummary): Promise<InternalApprovalRecord>;
+export declare function buildResumePayload(binding: WorkspaceBundle["bindings"] extends Map<string, infer T> ? T : never, approval: InternalApprovalRecord, options: ResumeOptions): unknown;
+export {};

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

@@ -0,0 +1,56 @@
+import { isDeepAgentBinding } from "../../support/compiled-binding.js";
+export async function resolveApprovalRecord(persistence, options, thread) {
+    if (options.approvalId) {
+        const approval = await persistence.getApproval(options.approvalId);
+        if (!approval) {
+            throw new Error(`Unknown approval ${options.approvalId}`);
+        }
+        return approval;
+    }
+    const runId = options.runId ?? thread.latestRunId;
+    const approvals = await persistence.getRunApprovals(options.threadId ?? thread.threadId, runId);
+    const approval = approvals
+        .filter((candidate) => candidate.status === "pending")
+        .sort((left, right) => right.requestedAt.localeCompare(left.requestedAt))[0];
+    if (!approval) {
+        throw new Error(`No pending approval for run ${runId}`);
+    }
+    return approval;
+}
+export function buildResumePayload(binding, approval, options) {
+    if (!isDeepAgentBinding(binding)) {
+        return options.decision === "edit" && options.editedInput
+            ? { decision: "edit", editedInput: options.editedInput }
+            : (options.decision ?? "approve");
+    }
+    const decisionType = options.decision ?? "approve";
+    if (decisionType === "edit" && options.editedInput) {
+        return {
+            decisions: [
+                {
+                    type: "edit",
+                    editedAction: {
+                        name: approval.toolName,
+                        args: options.editedInput,
+                    },
+                },
+            ],
+        };
+    }
+    if (decisionType === "reject") {
+        return {
+            decisions: [
+                {
+                    type: "reject",
+                },
+            ],
+        };
+    }
+    return {
+        decisions: [
+            {
+                type: "approve",
+            },
+        ],
+    };
+}

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

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

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

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

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

@@ -0,0 +1,37 @@
+import type { HarnessEvent, InternalApprovalRecord, MessageContent, RunResult } from "../../../contracts/types.js";
+import type { RuntimePersistence } from "../../../persistence/types.js";
+type LifecyclePersistence = Pick<RuntimePersistence, "appendThreadMessage" | "getRunApprovals" | "resolveApproval" | "releaseRunClaim" | "clearRunCancel" | "clearRunRequest" | "getRunMeta">;
+type LifecycleRuntime<TBinding> = {
+    persistence: LifecyclePersistence;
+    emit: (threadId: string, runId: string, sequence: number, eventType: string, payload: Record<string, unknown>, source?: HarnessEvent["source"]) => Promise<HarnessEvent>;
+    setRunStateAndEmit: (threadId: string, runId: string, sequence: number, state: RunResult["state"], options: {
+        previousState: string | null;
+        checkpointRef?: string | null;
+        error?: string;
+    }) => Promise<HarnessEvent>;
+    requestApprovalAndEmit: (threadId: string, runId: string, input: MessageContent, interruptContent: string | undefined, checkpointRef: string, sequence: number) => Promise<{
+        approval: InternalApprovalRecord;
+        event: HarnessEvent;
+    }>;
+    synthesizeFinalResult: (binding: TBinding, input: MessageContent, actual: RunResult) => Promise<{
+        output: string;
+        finalMessageText?: string;
+        modelId: string;
+    } | null | undefined>;
+    reviewRunResult: (binding: TBinding, input: MessageContent, actual: RunResult) => Promise<{
+        modelId: string;
+        assessment: string;
+    } | null | undefined>;
+};
+export declare function appendAssistantMessage(persistence: Pick<RuntimePersistence, "appendThreadMessage">, threadId: string, runId: string, content?: string): Promise<void>;
+export declare function checkpointRefForState(threadId: string, runId: string, state: RunResult["state"]): string | null;
+export declare function expirePendingApprovals(runtime: Pick<LifecycleRuntime<never>, "persistence" | "emit">, threadId: string, runId: string): Promise<void>;
+export declare function finalizeCancelledRun(runtime: Pick<LifecycleRuntime<never>, "persistence" | "emit" | "setRunStateAndEmit">, threadId: string, runId: string, previousState: RunResult["state"] | null, reason?: string): Promise<RunResult>;
+export declare function synthesizeCompletedRun<TBinding>(runtime: Pick<LifecycleRuntime<TBinding>, "synthesizeFinalResult">, binding: TBinding, input: MessageContent, actual: RunResult): Promise<RunResult>;
+export declare function reviewCompletedRun<TBinding>(runtime: Pick<LifecycleRuntime<TBinding>, "reviewRunResult" | "emit">, binding: TBinding, threadId: string, runId: string, input: MessageContent, actual: RunResult): Promise<void>;
+export declare function finalizeContinuedRun<TBinding>(runtime: LifecycleRuntime<TBinding>, binding: TBinding, threadId: string, runId: string, input: MessageContent, actual: RunResult, options: {
+    previousState: RunResult["state"] | null;
+    stateSequence: number;
+    approvalSequence?: number;
+}): Promise<RunResult>;
+export {};

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

@@ -0,0 +1,109 @@
+export async function appendAssistantMessage(persistence, threadId, runId, content) {
+    if (!content) {
+        return;
+    }
+    await persistence.appendThreadMessage(threadId, {
+        role: "assistant",
+        content,
+        runId,
+        createdAt: new Date().toISOString(),
+    });
+}
+export function checkpointRefForState(threadId, runId, state) {
+    return state === "waiting_for_approval" ? `checkpoints/${threadId}/${runId}/cp-1` : null;
+}
+export async function expirePendingApprovals(runtime, threadId, runId) {
+    const approvals = await runtime.persistence.getRunApprovals(threadId, runId);
+    for (const approval of approvals) {
+        if (approval.status !== "pending") {
+            continue;
+        }
+        await runtime.persistence.resolveApproval(threadId, runId, approval.approvalId, "expired");
+        await runtime.emit(threadId, runId, 6, "approval.resolved", {
+            approvalId: approval.approvalId,
+            pendingActionId: approval.pendingActionId,
+            decision: "cancel",
+            toolName: approval.toolName,
+        });
+    }
+}
+export async function finalizeCancelledRun(runtime, threadId, runId, previousState, reason) {
+    await expirePendingApprovals(runtime, threadId, runId);
+    await runtime.persistence.releaseRunClaim(runId);
+    await runtime.persistence.clearRunCancel(runId);
+    await runtime.persistence.clearRunRequest(threadId, runId);
+    await runtime.setRunStateAndEmit(threadId, runId, 104, "cancelled", {
+        previousState,
+        ...(reason ? { error: reason } : {}),
+    });
+    const runMeta = await runtime.persistence.getRunMeta(threadId, runId);
+    return {
+        threadId,
+        runId,
+        agentId: runMeta.agentId,
+        state: "cancelled",
+        output: reason ? `cancelled: ${reason}` : "cancelled",
+    };
+}
+export async function synthesizeCompletedRun(runtime, binding, input, actual) {
+    try {
+        const synthesized = await runtime.synthesizeFinalResult(binding, input, actual);
+        if (!synthesized) {
+            return actual;
+        }
+        return {
+            ...actual,
+            output: synthesized.output,
+            finalMessageText: synthesized.finalMessageText,
+            metadata: {
+                ...(typeof actual.metadata === "object" && actual.metadata ? actual.metadata : {}),
+                finalSynthesis: {
+                    modelId: synthesized.modelId,
+                },
+            },
+        };
+    }
+    catch {
+        return actual;
+    }
+}
+export async function reviewCompletedRun(runtime, binding, threadId, runId, input, actual) {
+    try {
+        const review = await runtime.reviewRunResult(binding, input, actual);
+        if (!review) {
+            return;
+        }
+        await runtime.emit(threadId, runId, 7, "run.reviewed", {
+            modelId: review.modelId,
+            assessment: review.assessment,
+        });
+    }
+    catch {
+        // Review is advisory; do not fail the completed run if the review pass fails.
+    }
+}
+export async function finalizeContinuedRun(runtime, binding, threadId, runId, input, actual, options) {
+    let approval;
+    const finalizedActual = actual.state === "completed"
+        ? await synthesizeCompletedRun(runtime, binding, input, actual)
+        : actual;
+    await appendAssistantMessage(runtime.persistence, threadId, runId, finalizedActual.output);
+    const checkpointRef = checkpointRefForState(threadId, runId, actual.state);
+    await runtime.setRunStateAndEmit(threadId, runId, options.stateSequence, finalizedActual.state, {
+        previousState: options.previousState,
+        checkpointRef,
+    });
+    if (finalizedActual.state === "waiting_for_approval" && options.approvalSequence) {
+        approval = (await runtime.requestApprovalAndEmit(threadId, runId, input, finalizedActual.interruptContent, checkpointRef, options.approvalSequence)).approval;
+    }
+    if (finalizedActual.state === "completed") {
+        await reviewCompletedRun(runtime, binding, threadId, runId, input, finalizedActual);
+    }
+    return {
+        ...finalizedActual,
+        threadId,
+        runId,
+        approvalId: approval?.approvalId ?? finalizedActual.approvalId,
+        pendingActionId: approval?.pendingActionId ?? finalizedActual.pendingActionId,
+    };
+}

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

@@ -0,0 +1,17 @@
+export type PendingRunSlot = {
+    threadId?: string;
+    runId?: string;
+    priority: number;
+    insertionOrder: number;
+    activate: () => void | Promise<void>;
+    abort: () => void;
+};
+export type QueuePositionChange = {
+    threadId: string;
+    runId: string;
+    priority: number;
+    queuePosition: number;
+};
+export declare function enqueuePendingRunSlot(pendingRunSlots: PendingRunSlot[], entry: Omit<PendingRunSlot, "insertionOrder">, insertionOrder: number): QueuePositionChange[];
+export declare function shiftNextPendingRunSlot(pendingRunSlots: PendingRunSlot[]): PendingRunSlot | undefined;
+export declare function dropPendingRunSlot(pendingRunSlots: PendingRunSlot[], runId: string): boolean;

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

@@ -0,0 +1,43 @@
+export function enqueuePendingRunSlot(pendingRunSlots, entry, insertionOrder) {
+    const previousPositions = new Map(pendingRunSlots
+        .filter((candidate) => Boolean(candidate.threadId && candidate.runId))
+        .map((candidate, index) => [candidate.runId, index + 1]));
+    pendingRunSlots.push({
+        ...entry,
+        insertionOrder,
+    });
+    pendingRunSlots.sort((left, right) => {
+        if (right.priority !== left.priority) {
+            return right.priority - left.priority;
+        }
+        return left.insertionOrder - right.insertionOrder;
+    });
+    return pendingRunSlots.flatMap((candidate, index) => {
+        if (!candidate.threadId || !candidate.runId) {
+            return [];
+        }
+        const previousPosition = previousPositions.get(candidate.runId);
+        const queuePosition = index + 1;
+        if (previousPosition === undefined || previousPosition === queuePosition) {
+            return [];
+        }
+        return [{
+                threadId: candidate.threadId,
+                runId: candidate.runId,
+                priority: candidate.priority,
+                queuePosition,
+            }];
+    });
+}
+export function shiftNextPendingRunSlot(pendingRunSlots) {
+    return pendingRunSlots.shift();
+}
+export function dropPendingRunSlot(pendingRunSlots, runId) {
+    const index = pendingRunSlots.findIndex((entry) => entry.runId === runId);
+    if (index < 0) {
+        return false;
+    }
+    const [entry] = pendingRunSlots.splice(index, 1);
+    entry?.abort();
+    return true;
+}

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

@@ -1,6 +1,6 @@
-import type { RuntimeHealthSnapshot, WorkspaceBundle } from "../contracts/types.js";
-import type { RuntimePersistence } from "../persistence/types.js";
-import type { MaintenanceLoopStatus } from "./checkpoint-maintenance.js";
+import type { RuntimeHealthSnapshot, WorkspaceBundle } from "../../../contracts/types.js";
+import type { RuntimePersistence } from "../../../persistence/types.js";
+import type { MaintenanceLoopStatus } from "../../maintenance/checkpoint-maintenance.js";
 type HealthMonitorConfig = {
     enabled: boolean;
     evaluateIntervalSeconds: number;

package/dist/runtime/{health-monitor.js → harness/system/health-monitor.js}

@@ -1,7 +1,7 @@
 import path from "node:path";
 import { readdir, stat } from "node:fs/promises";
-import { getRuntimeDefaults } from "../workspace/support/workspace-ref-utils.js";
-import { discoverCheckpointMaintenanceTargets } from "./checkpoint-maintenance.js";
+import { getRuntimeDefaults } from "../../../workspace/support/workspace-ref-utils.js";
+import { discoverCheckpointMaintenanceTargets } from "../../maintenance/checkpoint-maintenance.js";
 const DEFAULT_HEALTH_CONFIG = {
     enabled: false,
     evaluateIntervalSeconds: 30,

package/dist/runtime/{inventory.d.ts → harness/system/inventory.d.ts}

@@ -1,5 +1,5 @@
-import type { CompiledAgentBinding, WorkspaceBundle } from "../contracts/types.js";
-import type { OpenClawSkillMetadata } from "./support/skill-metadata.js";
+import type { CompiledAgentBinding, WorkspaceBundle } from "../../../contracts/types.js";
+import type { OpenClawSkillMetadata } from "../../support/skill-metadata.js";
 import { type RequirementAssessmentOptions, type SkillRequirementAssessment } from "./skill-requirements.js";
 export type InventoryToolRecord = {
     name: string;

package/dist/runtime/{inventory.js → harness/system/inventory.js}

@@ -1,8 +1,8 @@
-import { readSkillMetadata } from "./support/skill-metadata.js";
-import { getBindingPrimaryTools } from "./support/compiled-binding.js";
+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";
+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));
 }

package/dist/runtime/{policy-engine.d.ts → harness/system/policy-engine.d.ts}

@@ -1,4 +1,4 @@
-import type { CompiledAgentBinding } from "../contracts/types.js";
+import type { CompiledAgentBinding } from "../../../contracts/types.js";
 export type PolicyEngineDecision = {
     allowed: boolean;
     reasons: string[];

package/dist/runtime/{policy-engine.js → harness/system/policy-engine.js}

@@ -1,4 +1,4 @@
-import { getPolicyEvaluators } from "../extensions.js";
+import { getPolicyEvaluators } from "../../../extensions.js";
 export class PolicyEngine {
     evaluate(binding) {
         const reasons = [];

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

@@ -1,4 +1,4 @@
-import type { OpenClawSkillMetadata, SkillMetadata } from "./support/skill-metadata.js";
+import type { OpenClawSkillMetadata, SkillMetadata } from "../../support/skill-metadata.js";
 export type RequirementStatus = "satisfied" | "missing" | "unknown";
 export type RequirementCheckRecord = {
     name: string;

package/dist/runtime/{skill-requirements.js → harness/system/skill-requirements.js}

@@ -1,6 +1,6 @@
 import path from "node:path";
 import { existsSync } from "node:fs";
-import { augmentExecutablePath } from "./support/runtime-env.js";
+import { augmentExecutablePath } from "../../support/runtime-env.js";
 function dedupe(items) {
     return Array.from(new Set(items.filter(Boolean)));
 }

package/dist/runtime/{thread-memory-sync.d.ts → harness/system/thread-memory-sync.d.ts}

@@ -1,5 +1,5 @@
-import type { HarnessEvent, HarnessEventProjection } from "../contracts/types.js";
-import type { RuntimePersistence } from "../persistence/types.js";
+import type { HarnessEvent, HarnessEventProjection } from "../../../contracts/types.js";
+import type { RuntimePersistence } from "../../../persistence/types.js";
 export declare class ThreadMemorySync implements HarnessEventProjection {
     private readonly persistence;
     private readonly store?;

package/dist/runtime/{thread-memory-sync.js → harness/system/thread-memory-sync.js}

@@ -1,4 +1,4 @@
-import { extractMessageText } from "../utils/message-content.js";
+import { extractMessageText } from "../../../utils/message-content.js";
 function excerpt(message) {
     if (!message?.content) {
         return "(none)";