@botbotgo/agent-harness 0.0.103 → 0.0.105

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.104";

package/dist/package-version.js

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

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/system/health-monitor.d.ts

@@ -24,18 +24,6 @@ type HealthMonitorConfig = {
             degradedAbove: number;
             unhealthyAbove: number;
         };
-        checkpointBytes: {
-            degradedAbove: number;
-            unhealthyAbove: number;
-        };
-        runtimeDbBytes: {
-            degradedAbove: number;
-            unhealthyAbove: number;
-        };
-        artifactBytes: {
-            degradedAbove: number;
-            unhealthyAbove: number;
-        };
     };
 };
 type HealthMonitorOptions = {
@@ -51,12 +39,9 @@ export declare function readHealthMonitorConfig(workspace: WorkspaceBundle): Hea
 export declare class HealthMonitor {
     private readonly options;
     private readonly config;
-    private readonly runRoots;
-    private readonly checkpointDbPaths;
     private readonly llmSamples;
     private timer;
     private latestSnapshot;
-    private runtimeEventSequence;
     constructor(options: HealthMonitorOptions);
     recordLlmSuccess(latencyMs: number, nowMs?: number): void;
     recordLlmFailure(latencyMs: number, nowMs?: number): void;
@@ -67,15 +52,7 @@ export declare class HealthMonitor {
     evaluate(nowMs?: number): Promise<RuntimeHealthSnapshot>;
     private llmStats;
     private evaluateLlmCheck;
-    private llmSymptoms;
-    private evaluatePersistenceCheck;
-    private evaluateCapacityCheck;
-    private capacitySymptoms;
     private evaluateWorkloadCheck;
-    private workloadSymptoms;
     private countStuckRuns;
-    private sumRuntimeDbBytes;
-    private sumCheckpointDbBytes;
-    private sumArtifactBytes;
 }
 export {};

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

@@ -1,7 +1,4 @@
-import path from "node:path";
-import { readdir, stat } from "node:fs/promises";
 import { getRuntimeDefaults } from "../../../workspace/support/workspace-ref-utils.js";
-import { discoverCheckpointMaintenanceTargets } from "../../maintenance/checkpoint-maintenance.js";
 const DEFAULT_HEALTH_CONFIG = {
     enabled: false,
     evaluateIntervalSeconds: 30,
@@ -25,18 +22,6 @@ const DEFAULT_HEALTH_CONFIG = {
             degradedAbove: 300,
             unhealthyAbove: 900,
         },
-        checkpointBytes: {
-            degradedAbove: 512 * 1024 * 1024,
-            unhealthyAbove: 2 * 1024 * 1024 * 1024,
-        },
-        runtimeDbBytes: {
-            degradedAbove: 256 * 1024 * 1024,
-            unhealthyAbove: 1024 * 1024 * 1024,
-        },
-        artifactBytes: {
-            degradedAbove: 512 * 1024 * 1024,
-            unhealthyAbove: 2 * 1024 * 1024 * 1024,
-        },
     },
 };
 function asObject(value) {
@@ -52,23 +37,18 @@ function maxStatus(left, right) {
     const rank = { healthy: 0, degraded: 1, unhealthy: 2 };
     return rank[left] >= rank[right] ? left : right;
 }
-function compareStatus(left, right) {
-    return left === right;
-}
-function computeP95(values) {
-    if (values.length === 0) {
-        return undefined;
-    }
-    const sorted = [...values].sort((a, b) => a - b);
-    const index = Math.min(sorted.length - 1, Math.max(0, Math.ceil(sorted.length * 0.95) - 1));
-    return sorted[index];
-}
-function isoFromMs(value) {
-    return new Date(value).toISOString();
-}
 function buildCheck(status, updatedAt, reason) {
     return reason ? { status, updatedAt, reason } : { status, updatedAt };
 }
+function createSymptom(code, status, message, timestamp) {
+    return {
+        code,
+        severity: status === "unhealthy" ? "error" : status === "degraded" ? "warn" : "info",
+        message,
+        firstSeenAt: timestamp,
+        lastSeenAt: timestamp,
+    };
+}
 function describeThresholdStatus(value, thresholds) {
     if (value >= thresholds.unhealthyAbove) {
         return "unhealthy";
@@ -78,6 +58,14 @@ function describeThresholdStatus(value, thresholds) {
     }
     return "healthy";
 }
+function computeP95(values) {
+    if (values.length === 0) {
+        return undefined;
+    }
+    const sorted = [...values].sort((a, b) => a - b);
+    const index = Math.min(sorted.length - 1, Math.max(0, Math.ceil(sorted.length * 0.95) - 1));
+    return sorted[index];
+}
 export function readHealthMonitorConfig(workspace) {
     const runtimeDefaults = getRuntimeDefaults(workspace.refs);
     const observability = asObject(runtimeDefaults?.observability);
@@ -87,9 +75,6 @@ export function readHealthMonitorConfig(workspace) {
     const llmP95LatencyMs = asObject(thresholds?.llmP95LatencyMs);
     const pendingApprovals = asObject(thresholds?.pendingApprovals);
     const stuckRunSeconds = asObject(thresholds?.stuckRunSeconds);
-    const checkpointBytes = asObject(thresholds?.checkpointBytes);
-    const runtimeDbBytes = asObject(thresholds?.runtimeDbBytes);
-    const artifactBytes = asObject(thresholds?.artifactBytes);
     return {
         enabled: health?.enabled === true,
         evaluateIntervalSeconds: readPositiveNumber(health?.evaluateIntervalSeconds, DEFAULT_HEALTH_CONFIG.evaluateIntervalSeconds),
@@ -113,112 +98,18 @@ export function readHealthMonitorConfig(workspace) {
                 degradedAbove: readNonNegativeNumber(stuckRunSeconds?.degradedAbove, DEFAULT_HEALTH_CONFIG.thresholds.stuckRunSeconds.degradedAbove),
                 unhealthyAbove: readNonNegativeNumber(stuckRunSeconds?.unhealthyAbove, DEFAULT_HEALTH_CONFIG.thresholds.stuckRunSeconds.unhealthyAbove),
             },
-            checkpointBytes: {
-                degradedAbove: readNonNegativeNumber(checkpointBytes?.degradedAbove, DEFAULT_HEALTH_CONFIG.thresholds.checkpointBytes.degradedAbove),
-                unhealthyAbove: readNonNegativeNumber(checkpointBytes?.unhealthyAbove, DEFAULT_HEALTH_CONFIG.thresholds.checkpointBytes.unhealthyAbove),
-            },
-            runtimeDbBytes: {
-                degradedAbove: readNonNegativeNumber(runtimeDbBytes?.degradedAbove, DEFAULT_HEALTH_CONFIG.thresholds.runtimeDbBytes.degradedAbove),
-                unhealthyAbove: readNonNegativeNumber(runtimeDbBytes?.unhealthyAbove, DEFAULT_HEALTH_CONFIG.thresholds.runtimeDbBytes.unhealthyAbove),
-            },
-            artifactBytes: {
-                degradedAbove: readNonNegativeNumber(artifactBytes?.degradedAbove, DEFAULT_HEALTH_CONFIG.thresholds.artifactBytes.degradedAbove),
-                unhealthyAbove: readNonNegativeNumber(artifactBytes?.unhealthyAbove, DEFAULT_HEALTH_CONFIG.thresholds.artifactBytes.unhealthyAbove),
-            },
         },
     };
 }
-async function safeFileSize(filePath) {
-    try {
-        const stats = await stat(filePath);
-        return stats.size;
-    }
-    catch {
-        return 0;
-    }
-}
-async function directorySize(root) {
-    try {
-        const entries = await readdir(root, { withFileTypes: true });
-        let total = 0;
-        for (const entry of entries) {
-            const fullPath = path.join(root, entry.name);
-            if (entry.isDirectory()) {
-                total += await directorySize(fullPath);
-                continue;
-            }
-            if (entry.isFile()) {
-                total += await safeFileSize(fullPath);
-            }
-        }
-        return total;
-    }
-    catch {
-        return 0;
-    }
-}
-function evaluateMaintenanceStatus(label, status, updatedAt) {
-    if (!status) {
-        return {
-            check: buildCheck("healthy", updatedAt, `${label} disabled`),
-            symptoms: [],
-        };
-    }
-    if (status.consecutiveFailures > 0) {
-        return {
-            check: buildCheck("degraded", updatedAt, `${label} has ${status.consecutiveFailures} consecutive failure(s)`),
-            symptoms: [{
-                    code: `${label}.loop.failure`,
-                    severity: "warn",
-                    message: status.lastError ?? `${label} maintenance loop failed`,
-                    firstSeenAt: status.lastFailedAt ?? updatedAt,
-                    lastSeenAt: status.lastFailedAt ?? updatedAt,
-                }],
-        };
-    }
-    if (status.lastCompletedAt) {
-        return {
-            check: buildCheck("healthy", updatedAt, `${label} completed successfully`),
-            symptoms: [],
-        };
-    }
-    return {
-        check: buildCheck("healthy", updatedAt, `${label} idle`),
-        symptoms: [],
-    };
-}
-function normalizeSeverity(status) {
-    if (status === "unhealthy") {
-        return "error";
-    }
-    if (status === "degraded") {
-        return "warn";
-    }
-    return "info";
-}
-function createSymptom(code, status, message, timestamp) {
-    return {
-        code,
-        severity: normalizeSeverity(status),
-        message,
-        firstSeenAt: timestamp,
-        lastSeenAt: timestamp,
-    };
-}
 export class HealthMonitor {
     options;
     config;
-    runRoots;
-    checkpointDbPaths;
     llmSamples = [];
     timer = null;
     latestSnapshot = null;
-    runtimeEventSequence = 0;
     constructor(options) {
         this.options = options;
         this.config = readHealthMonitorConfig(options.workspace);
-        this.runRoots = Array.from(new Set(Array.from(options.workspace.bindings.values()).map((binding) => binding.harnessRuntime.runRoot)));
-        this.checkpointDbPaths = Array.from(new Set(discoverCheckpointMaintenanceTargets(options.workspace).map((target) => target.dbPath)));
     }
     recordLlmSuccess(latencyMs, nowMs = Date.now()) {
         this.recordLlmSample({ timestampMs: nowMs, latencyMs, success: true });
@@ -253,172 +144,96 @@ export class HealthMonitor {
         return this.evaluate();
     }
     async evaluate(nowMs = Date.now()) {
-        const updatedAt = isoFromMs(nowMs);
-        const [runs, approvals, runtimeDbBytes, checkpointBytes, artifactBytes] = await Promise.all([
+        const updatedAt = new Date(nowMs).toISOString();
+        const [runs, approvals] = await Promise.all([
             this.options.persistence.listRuns(),
             this.options.persistence.listApprovals(),
-            this.sumRuntimeDbBytes(),
-            this.sumCheckpointDbBytes(),
-            this.sumArtifactBytes(),
         ]);
         const pendingApprovals = approvals.filter((approval) => approval.status === "pending").length;
         const stuckRuns = this.countStuckRuns(runs, nowMs);
-        const runtimeMaintenance = evaluateMaintenanceStatus("checkpoint", this.options.getCheckpointMaintenanceStatus(), updatedAt);
-        const recordMaintenance = evaluateMaintenanceStatus("records", this.options.getRuntimeRecordMaintenanceStatus(), updatedAt);
-        let runtimeCheck = buildCheck("healthy", updatedAt, "runtime loops healthy");
-        const runtimeSymptoms = [...runtimeMaintenance.symptoms, ...recordMaintenance.symptoms];
-        runtimeCheck = buildCheck(maxStatus(runtimeMaintenance.check.status, recordMaintenance.check.status), updatedAt, runtimeSymptoms.length > 0 ? runtimeSymptoms.map((symptom) => symptom.message).join("; ") : "runtime loops healthy");
         const llmCheck = this.evaluateLlmCheck(updatedAt, nowMs);
-        const persistenceCheck = this.evaluatePersistenceCheck(updatedAt, runtimeDbBytes, runtimeSymptoms);
-        const capacityCheck = this.evaluateCapacityCheck(updatedAt, checkpointBytes, runtimeDbBytes, artifactBytes);
         const workloadCheck = this.evaluateWorkloadCheck(updatedAt, pendingApprovals, stuckRuns);
-        const symptoms = [
-            ...runtimeSymptoms,
-            ...this.capacitySymptoms(capacityCheck, checkpointBytes, runtimeDbBytes, artifactBytes, updatedAt),
-            ...this.workloadSymptoms(workloadCheck, pendingApprovals, stuckRuns, updatedAt),
-            ...this.llmSymptoms(llmCheck, updatedAt),
-            ...(persistenceCheck.status === "healthy"
-                ? []
-                : [createSymptom("persistence.runtime-db", persistenceCheck.status, persistenceCheck.reason ?? "runtime persistence degraded", updatedAt)]),
-        ];
-        const checks = {
-            runtime: runtimeCheck,
-            llm: llmCheck,
-            persistence: persistenceCheck,
-            capacity: capacityCheck,
-            workload: workloadCheck,
-        };
+        const runtimeCheck = buildCheck("healthy", updatedAt, "runtime health monitoring enabled");
+        const persistenceCheck = buildCheck("healthy", updatedAt, "runtime persistence accessible");
+        const capacityCheck = buildCheck("healthy", updatedAt, "capacity checks disabled");
+        const symptoms = [];
+        if (describeThresholdStatus(pendingApprovals, this.config.thresholds.pendingApprovals) !== "healthy") {
+            symptoms.push(createSymptom("workload.pending-approvals", describeThresholdStatus(pendingApprovals, this.config.thresholds.pendingApprovals), `pendingApprovals=${pendingApprovals}`, updatedAt));
+        }
+        if (stuckRuns > 0) {
+            symptoms.push(createSymptom("workload.stuck-runs", workloadCheck.status, `stuckRuns=${stuckRuns}`, updatedAt));
+        }
+        if (llmCheck.status !== "healthy") {
+            symptoms.push(createSymptom("llm.invocations", llmCheck.status, llmCheck.reason ?? "llm health degraded", updatedAt));
+        }
         let overallStatus = "healthy";
-        for (const check of Object.values(checks)) {
+        for (const check of [runtimeCheck, llmCheck, persistenceCheck, capacityCheck, workloadCheck]) {
             overallStatus = maxStatus(overallStatus, check.status);
         }
         const snapshot = {
             status: overallStatus,
             updatedAt,
-            checks,
+            checks: {
+                runtime: runtimeCheck,
+                llm: llmCheck,
+                persistence: persistenceCheck,
+                capacity: capacityCheck,
+                workload: workloadCheck,
+            },
             symptoms,
             stats: {
                 activeRunSlots: this.options.getActiveRunSlots(),
                 pendingRunSlots: this.options.getPendingRunSlots(),
                 pendingApprovals,
                 stuckRuns,
-                checkpointBytes,
-                runtimeDbBytes,
-                artifactBytes,
                 ...this.llmStats(nowMs),
             },
         };
-        const previous = this.latestSnapshot;
-        this.latestSnapshot = snapshot;
         if (this.config.enabled &&
             this.config.emitEvents &&
             this.options.publishEvent &&
-            previous &&
-            !compareStatus(previous.status, snapshot.status)) {
+            this.latestSnapshot &&
+            this.latestSnapshot.status !== snapshot.status) {
             await this.options.publishEvent({
-                previousStatus: previous.status,
+                previousStatus: this.latestSnapshot.status,
                 status: snapshot.status,
                 checks: snapshot.checks,
                 stats: snapshot.stats,
             });
         }
+        this.latestSnapshot = snapshot;
         return snapshot;
     }
     llmStats(nowMs) {
-        const oneMinuteWindowMs = 60 * 1000;
-        const recent = this.llmSamples.filter((sample) => nowMs - sample.timestampMs <= oneMinuteWindowMs);
+        const recent = this.llmSamples.filter((sample) => nowMs - sample.timestampMs <= 60 * 1000);
         const successes = recent.filter((sample) => sample.success).length;
-        const latencies = recent.map((sample) => sample.latencyMs);
         return {
             llmSuccessRate1m: recent.length > 0 ? successes / recent.length : undefined,
-            llmP95LatencyMs1m: computeP95(latencies),
+            llmP95LatencyMs1m: computeP95(recent.map((sample) => sample.latencyMs)),
         };
     }
     evaluateLlmCheck(updatedAt, nowMs) {
-        const errorWindow = this.config.thresholds.llmErrorRate.windowSeconds * 1000;
-        const latencyWindow = this.config.thresholds.llmP95LatencyMs.windowSeconds * 1000;
-        const errorSamples = this.llmSamples.filter((sample) => nowMs - sample.timestampMs <= errorWindow);
-        const latencySamples = this.llmSamples.filter((sample) => nowMs - sample.timestampMs <= latencyWindow);
+        const errorSamples = this.llmSamples.filter((sample) => nowMs - sample.timestampMs <= this.config.thresholds.llmErrorRate.windowSeconds * 1000);
+        const latencySamples = this.llmSamples.filter((sample) => nowMs - sample.timestampMs <= this.config.thresholds.llmP95LatencyMs.windowSeconds * 1000);
         if (errorSamples.length === 0 && latencySamples.length === 0) {
             return buildCheck("healthy", updatedAt, "no recent llm invocations");
         }
-        const errors = errorSamples.filter((sample) => !sample.success).length;
-        const errorRate = errorSamples.length > 0 ? errors / errorSamples.length : 0;
+        const errorRate = errorSamples.length > 0
+            ? errorSamples.filter((sample) => !sample.success).length / errorSamples.length
+            : 0;
         const p95Latency = computeP95(latencySamples.map((sample) => sample.latencyMs));
-        let status = "healthy";
-        if (errorRate >= this.config.thresholds.llmErrorRate.unhealthyAbove) {
-            status = "unhealthy";
-        }
-        else if (errorRate >= this.config.thresholds.llmErrorRate.degradedAbove) {
-            status = "degraded";
-        }
+        let status = describeThresholdStatus(errorRate, this.config.thresholds.llmErrorRate);
         if (p95Latency !== undefined) {
-            const latencyStatus = describeThresholdStatus(p95Latency, this.config.thresholds.llmP95LatencyMs);
-            status = maxStatus(status, latencyStatus);
+            status = maxStatus(status, describeThresholdStatus(p95Latency, this.config.thresholds.llmP95LatencyMs));
         }
         return buildCheck(status, updatedAt, `errorRate=${errorRate.toFixed(2)}${p95Latency !== undefined ? ` p95LatencyMs=${Math.round(p95Latency)}` : ""}`);
     }
-    llmSymptoms(check, updatedAt) {
-        if (check.status === "healthy") {
-            return [];
-        }
-        return [createSymptom("llm.invocations", check.status, check.reason ?? "llm health degraded", updatedAt)];
-    }
-    evaluatePersistenceCheck(updatedAt, runtimeDbBytes, runtimeSymptoms) {
-        if (runtimeSymptoms.length > 0) {
-            return buildCheck("degraded", updatedAt, runtimeSymptoms.map((symptom) => symptom.message).join("; "));
-        }
-        if (runtimeDbBytes === 0) {
-            return buildCheck("healthy", updatedAt, "runtime sqlite not materialized yet");
-        }
-        return buildCheck("healthy", updatedAt, "runtime sqlite accessible");
-    }
-    evaluateCapacityCheck(updatedAt, checkpointBytes, runtimeDbBytes, artifactBytes) {
-        let status = "healthy";
-        status = maxStatus(status, describeThresholdStatus(checkpointBytes, this.config.thresholds.checkpointBytes));
-        status = maxStatus(status, describeThresholdStatus(runtimeDbBytes, this.config.thresholds.runtimeDbBytes));
-        status = maxStatus(status, describeThresholdStatus(artifactBytes, this.config.thresholds.artifactBytes));
-        return buildCheck(status, updatedAt, `checkpointBytes=${checkpointBytes} runtimeDbBytes=${runtimeDbBytes} artifactBytes=${artifactBytes}`);
-    }
-    capacitySymptoms(check, checkpointBytes, runtimeDbBytes, artifactBytes, updatedAt) {
-        if (check.status === "healthy") {
-            return [];
-        }
-        const symptoms = [];
-        if (describeThresholdStatus(checkpointBytes, this.config.thresholds.checkpointBytes) !== "healthy") {
-            symptoms.push(createSymptom("capacity.checkpoints", describeThresholdStatus(checkpointBytes, this.config.thresholds.checkpointBytes), `checkpointBytes=${checkpointBytes}`, updatedAt));
-        }
-        if (describeThresholdStatus(runtimeDbBytes, this.config.thresholds.runtimeDbBytes) !== "healthy") {
-            symptoms.push(createSymptom("capacity.runtime-db", describeThresholdStatus(runtimeDbBytes, this.config.thresholds.runtimeDbBytes), `runtimeDbBytes=${runtimeDbBytes}`, updatedAt));
-        }
-        if (describeThresholdStatus(artifactBytes, this.config.thresholds.artifactBytes) !== "healthy") {
-            symptoms.push(createSymptom("capacity.artifacts", describeThresholdStatus(artifactBytes, this.config.thresholds.artifactBytes), `artifactBytes=${artifactBytes}`, updatedAt));
-        }
-        return symptoms;
-    }
     evaluateWorkloadCheck(updatedAt, pendingApprovals, stuckRuns) {
         let status = describeThresholdStatus(pendingApprovals, this.config.thresholds.pendingApprovals);
-        status = maxStatus(status, describeThresholdStatus(stuckRuns, {
-            degradedAbove: this.config.thresholds.stuckRunSeconds.degradedAbove > 0 ? 1 : Number.MAX_SAFE_INTEGER,
-            unhealthyAbove: this.config.thresholds.stuckRunSeconds.unhealthyAbove > 0 ? 1 : Number.MAX_SAFE_INTEGER,
-        }));
-        return buildCheck(status, updatedAt, `pendingApprovals=${pendingApprovals} stuckRuns=${stuckRuns}`);
-    }
-    workloadSymptoms(check, pendingApprovals, stuckRuns, updatedAt) {
-        if (check.status === "healthy") {
-            return [];
-        }
-        const symptoms = [];
-        if (describeThresholdStatus(pendingApprovals, this.config.thresholds.pendingApprovals) !== "healthy") {
-            symptoms.push(createSymptom("workload.pending-approvals", describeThresholdStatus(pendingApprovals, this.config.thresholds.pendingApprovals), `pendingApprovals=${pendingApprovals}`, updatedAt));
-        }
         if (stuckRuns > 0) {
-            const stuckStatus = stuckRuns >= 1 && this.config.thresholds.stuckRunSeconds.unhealthyAbove <= this.config.thresholds.stuckRunSeconds.degradedAbove
-                ? "unhealthy"
-                : "degraded";
-            symptoms.push(createSymptom("workload.stuck-runs", stuckStatus, `stuckRuns=${stuckRuns}`, updatedAt));
+            status = maxStatus(status, stuckRuns >= this.config.thresholds.stuckRunSeconds.unhealthyAbove ? "unhealthy" : "degraded");
         }
-        return symptoms;
+        return buildCheck(status, updatedAt, `pendingApprovals=${pendingApprovals} stuckRuns=${stuckRuns}`);
     }
     countStuckRuns(runs, nowMs) {
         return runs.filter((run) => {
@@ -429,20 +244,7 @@ export class HealthMonitor {
             if (!Number.isFinite(updatedAtMs)) {
                 return false;
             }
-            const ageSeconds = (nowMs - updatedAtMs) / 1000;
-            return ageSeconds >= this.config.thresholds.stuckRunSeconds.degradedAbove;
+            return (nowMs - updatedAtMs) / 1000 >= this.config.thresholds.stuckRunSeconds.degradedAbove;
         }).length;
     }
-    async sumRuntimeDbBytes() {
-        const sizes = await Promise.all(this.runRoots.map((runRoot) => safeFileSize(path.join(runRoot, "runtime.sqlite"))));
-        return sizes.reduce((sum, value) => sum + value, 0);
-    }
-    async sumCheckpointDbBytes() {
-        const sizes = await Promise.all(this.checkpointDbPaths.map((dbPath) => safeFileSize(dbPath)));
-        return sizes.reduce((sum, value) => sum + value, 0);
-    }
-    async sumArtifactBytes() {
-        const sizes = await Promise.all(this.runRoots.map((runRoot) => directorySize(path.join(runRoot, "threads"))));
-        return sizes.reduce((sum, value) => sum + value, 0);
-    }
 }

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.105",
   "description": "Workspace runtime for multi-agent applications",
   "type": "module",
   "packageManager": "npm@10.9.2",