@botbotgo/agent-harness 0.0.103 → 0.0.104

package/dist/package-version.d.ts

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

package/dist/package-version.js

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

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

@@ -1,22 +1,17 @@
 import type { RunResult, ThreadSummary } from "../../../contracts/types.js";
 import type { RuntimePersistence } from "../../../persistence/types.js";
 import type { ConcurrencyConfig, RecoveryConfig } from "../../../workspace/support/workspace-ref-utils.js";
-import { recoverQueuedStartupRun } from "./recovery.js";
 type Startable = {
     start(): Promise<void>;
 };
-type StartupRecoveryContext = Parameters<typeof recoverQueuedStartupRun>[0];
 export declare function initializeHarnessRuntime(input: {
     persistence: RuntimePersistence;
-    checkpointMaintenance: Startable | null;
-    runtimeRecordMaintenance: Startable | null;
     healthMonitor: Startable | null;
-    recoverStartupRuns: () => Promise<void>;
 }): Promise<void>;
 export declare function recoverStartupRuns(input: {
     recoveryConfig: RecoveryConfig;
     persistence: RuntimePersistence;
-    createStartupRecoveryContext: () => StartupRecoveryContext;
+    createStartupRecoveryContext: () => unknown;
     reclaimExpiredClaimedRuns: (nowIso?: string) => Promise<void>;
 }): Promise<void>;
 export declare function reclaimExpiredClaimedRuns(input: {

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

@@ -1,58 +1,13 @@
-import { recoverQueuedStartupRun, recoverResumingStartupRun, recoverRunningStartupRun, } from "./recovery.js";
 export async function initializeHarnessRuntime(input) {
     await input.persistence.initialize();
-    await input.checkpointMaintenance?.start();
-    await input.runtimeRecordMaintenance?.start();
     await input.healthMonitor?.start();
-    await input.recoverStartupRuns();
 }
 export async function recoverStartupRuns(input) {
-    if (!input.recoveryConfig.enabled) {
-        return;
-    }
-    await input.reclaimExpiredClaimedRuns();
-    const threads = await input.persistence.listSessions();
-    const recoveryContext = input.createStartupRecoveryContext();
-    for (const thread of threads) {
-        const handled = await recoverQueuedStartupRun(recoveryContext, thread) ||
-            await recoverRunningStartupRun(recoveryContext, thread) ||
-            await recoverResumingStartupRun(recoveryContext, thread);
-        if (handled) {
-            continue;
-        }
-    }
+    void input;
 }
 export async function reclaimExpiredClaimedRuns(input, nowIso = new Date().toISOString()) {
-    const expiredClaims = await input.persistence.listExpiredClaimedRuns(nowIso);
-    for (const claim of expiredClaims) {
-        const thread = await input.persistence.getSession(claim.threadId);
-        if (!thread) {
-            await input.persistence.releaseRunClaim(claim.runId);
-            continue;
-        }
-        const lifecycle = await input.persistence.getRunLifecycle(claim.threadId, claim.runId);
-        if (lifecycle.state === "claimed") {
-            await input.persistence.enqueueRun({
-                threadId: claim.threadId,
-                runId: claim.runId,
-                priority: claim.priority,
-                queueKey: claim.queueKey,
-                availableAt: nowIso,
-            });
-            await input.setRunStateAndEmit(claim.threadId, claim.runId, 99, "queued", {
-                previousState: "claimed",
-            });
-            await input.emit(claim.threadId, claim.runId, 100, "run.queued", {
-                queuePosition: 0,
-                activeRunCount: input.getActiveRunSlots(),
-                maxConcurrentRuns: input.concurrencyConfig.maxConcurrentRuns,
-                recoveredOnStartup: true,
-                reclaimReason: "expired-lease",
-            });
-            continue;
-        }
-        await input.persistence.releaseRunClaim(claim.runId);
-    }
+    void input;
+    void nowIso;
 }
 export async function isStaleRunningRun(input, thread, nowMs = Date.now()) {
     const control = await input.persistence.getRunControl(thread.latestRunId);

package/dist/runtime/harness.d.ts

@@ -22,8 +22,6 @@ export declare class AgentHarnessRuntime {
     private readonly threadMemorySync;
     private readonly unregisterThreadMemorySync;
     private readonly resolvedRuntimeAdapterOptions;
-    private readonly checkpointMaintenance;
-    private readonly runtimeRecordMaintenance;
     private readonly healthMonitor;
     private readonly recoveryConfig;
     private readonly concurrencyConfig;

package/dist/runtime/harness.js

@@ -9,10 +9,7 @@ import { getConcurrencyConfig, getRecoveryConfig, getRoutingDefaultAgentId, getR
 import { createHarnessEvent, inferRoutingBindings, renderRuntimeFailure, } from "./support/harness-support.js";
 import { ThreadMemorySync } from "./harness/system/thread-memory-sync.js";
 import { FileBackedStore } from "./harness/system/store.js";
-import { CheckpointMaintenanceLoop, discoverCheckpointMaintenanceTargets, readCheckpointMaintenanceConfig, } from "./maintenance/checkpoint-maintenance.js";
-import { RuntimeRecordMaintenanceLoop, discoverRuntimeRecordMaintenanceTargets, readRuntimeRecordMaintenanceConfig, } from "./maintenance/runtime-record-maintenance.js";
-import { HealthMonitor } from "./harness/system/health-monitor.js";
-import { readHealthMonitorConfig } from "./harness/system/health-monitor.js";
+import { HealthMonitor, readHealthMonitorConfig, } from "./harness/system/health-monitor.js";
 import { extractMessageText, normalizeMessageContent } from "../utils/message-content.js";
 import { buildPersistedRunRequest, normalizeInvocationEnvelope, normalizeRunPriority, resolveRunListeners, } from "./harness/run/helpers.js";
 import { emitHarnessEvent, emitRunCreatedEvent, emitSyntheticFallbackEvent, requestApprovalAndEmitEvent, setRunStateAndEmitEvent, } from "./harness/events/events.js";
@@ -29,7 +26,7 @@ import { getBindingAdapterKind, getBindingPrimaryTools, getBindingStoreConfig }
 import { isRuntimeEntryBinding } from "./support/runtime-entry.js";
 import { describeWorkspaceInventory, listAgentSkills as listWorkspaceAgentSkills, } from "./harness/system/inventory.js";
 import { createDefaultHealthSnapshot, isInventoryEnabled, isThreadMemorySyncEnabled, } from "./harness/runtime-defaults.js";
-import { initializeHarnessRuntime, isStaleRunningRun as isHarnessStaleRunningRun, reclaimExpiredClaimedRuns as reclaimHarnessExpiredClaimedRuns, recoverStartupRuns as recoverHarnessStartupRuns, } from "./harness/run/startup-runtime.js";
+import { initializeHarnessRuntime, isStaleRunningRun as isHarnessStaleRunningRun, } from "./harness/run/startup-runtime.js";
 import { streamHarnessRun } from "./harness/run/stream-run.js";
 import { deleteThreadRecord, getPublicApproval, getThreadRecord, listPublicApprovals, } from "./harness/run/thread-records.js";
 export class AgentHarnessRuntime {
@@ -58,8 +55,6 @@ export class AgentHarnessRuntime {
     threadMemorySync;
     unregisterThreadMemorySync;
     resolvedRuntimeAdapterOptions;
-    checkpointMaintenance;
-    runtimeRecordMaintenance;
     healthMonitor;
     recoveryConfig;
     concurrencyConfig;
@@ -127,14 +122,6 @@ export class AgentHarnessRuntime {
             this.threadMemorySync = null;
             this.unregisterThreadMemorySync = () => { };
         }
-        const checkpointMaintenanceConfig = readCheckpointMaintenanceConfig(workspace);
-        this.checkpointMaintenance = checkpointMaintenanceConfig
-            ? new CheckpointMaintenanceLoop(discoverCheckpointMaintenanceTargets(workspace), checkpointMaintenanceConfig)
-            : null;
-        const runtimeRecordMaintenanceConfig = readRuntimeRecordMaintenanceConfig(workspace);
-        this.runtimeRecordMaintenance = runtimeRecordMaintenanceConfig
-            ? new RuntimeRecordMaintenanceLoop(discoverRuntimeRecordMaintenanceTargets(workspace), runtimeRecordMaintenanceConfig)
-            : null;
         this.recoveryConfig = getRecoveryConfig(workspace.refs);
         this.concurrencyConfig = getConcurrencyConfig(workspace.refs);
         const healthConfig = readHealthMonitorConfig(workspace);
@@ -146,8 +133,8 @@ export class AgentHarnessRuntime {
             persistence: this.persistence,
             getActiveRunSlots: () => this.activeRunSlots,
             getPendingRunSlots: () => this.pendingRunSlots.length,
-            getCheckpointMaintenanceStatus: () => this.checkpointMaintenance?.getStatus() ?? null,
-            getRuntimeRecordMaintenanceStatus: () => this.runtimeRecordMaintenance?.getStatus() ?? null,
+            getCheckpointMaintenanceStatus: () => null,
+            getRuntimeRecordMaintenanceStatus: () => null,
             publishEvent: async (payload) => {
                 this.eventBus.publish(createHarnessEvent("__runtime__", "__runtime__", ++this.runtimeEventSequence, "runtime.health.changed", payload));
             },
@@ -162,10 +149,7 @@ export class AgentHarnessRuntime {
     async initialize() {
         await initializeHarnessRuntime({
             persistence: this.persistence,
-            checkpointMaintenance: this.checkpointMaintenance,
-            runtimeRecordMaintenance: this.runtimeRecordMaintenance,
             healthMonitor: this.healthMonitor,
-            recoverStartupRuns: () => this.recoverStartupRuns(),
         });
     }
     subscribe(listener) {
@@ -720,8 +704,6 @@ export class AgentHarnessRuntime {
     }
     async close() {
         await this.healthMonitor?.stop();
-        await this.checkpointMaintenance?.stop();
-        await this.runtimeRecordMaintenance?.stop();
         this.unregisterThreadMemorySync();
         await Promise.allSettled(Array.from(this.backgroundTasks));
         await this.threadMemorySync?.close();
@@ -739,21 +721,10 @@ export class AgentHarnessRuntime {
         }, options);
     }
     async recoverStartupRuns() {
-        await recoverHarnessStartupRuns({
-            recoveryConfig: this.recoveryConfig,
-            persistence: this.persistence,
-            createStartupRecoveryContext: () => this.createStartupRecoveryContext(),
-            reclaimExpiredClaimedRuns: (nowIso) => this.reclaimExpiredClaimedRuns(nowIso),
-        });
+        return;
     }
-    async reclaimExpiredClaimedRuns(nowIso = new Date().toISOString()) {
-        await reclaimHarnessExpiredClaimedRuns({
-            persistence: this.persistence,
-            setRunStateAndEmit: (threadId, runId, sequence, state, options) => this.setRunStateAndEmit(threadId, runId, sequence, state, options),
-            emit: (threadId, runId, sequence, eventType, payload) => this.emit(threadId, runId, sequence, eventType, payload),
-            concurrencyConfig: this.concurrencyConfig,
-            getActiveRunSlots: () => this.activeRunSlots,
-        }, nowIso);
+    async reclaimExpiredClaimedRuns(_nowIso = new Date().toISOString()) {
+        return;
     }
     async isStaleRunningRun(thread, nowMs = Date.now()) {
         return isHarnessStaleRunningRun({

package/package.json

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