@botbotgo/agent-harness 0.0.104 → 0.0.105

package/dist/package-version.d.ts

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

package/dist/package-version.js

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

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/package.json

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