@botbotgo/agent-harness 0.0.96 → 0.0.98

package/dist/runtime/index.d.ts

@@ -1,15 +1,15 @@
 export { AgentRuntimeAdapter, AGENT_INTERRUPT_SENTINEL_PREFIX } from "./agent-runtime-adapter.js";
-export { EventBus } from "./event-bus.js";
-export { createRuntimeEventSink, RuntimeEventSinkImpl } from "./event-sink.js";
+export { EventBus } from "./harness/events/event-bus.js";
+export { createRuntimeEventSink, RuntimeEventSinkImpl } from "./harness/events/event-sink.js";
 export { FileCheckpointSaver } from "./file-checkpoint-saver.js";
 export { CheckpointMaintenanceLoop, discoverCheckpointMaintenanceTargets, maintainSqliteCheckpoints, readCheckpointMaintenanceConfig, } from "./checkpoint-maintenance.js";
 export { ManagedSqliteSaver } from "./sqlite-maintained-checkpoint-saver.js";
 export { AgentHarnessRuntime, AgentHarness } from "./harness.js";
-export { describeWorkspaceInventory, findAgentBinding, listAgentSkills, listAgentTools, listAvailableAgents, listSpecialists, } from "./inventory.js";
-export { assessOpenClawRequirements, assessSkillRequirements, } from "./skill-requirements.js";
+export { describeWorkspaceInventory, findAgentBinding, listAgentSkills, listAgentTools, listAvailableAgents, listSpecialists, } from "./harness/system/inventory.js";
+export { assessOpenClawRequirements, assessSkillRequirements, } from "./harness/system/skill-requirements.js";
 export * from "./parsing/index.js";
-export { PolicyEngine } from "./policy-engine.js";
-export { createInMemoryStore, FileBackedStore } from "./store.js";
+export { PolicyEngine } from "./harness/system/policy-engine.js";
+export { createInMemoryStore, FileBackedStore } from "./harness/system/store.js";
 export * from "./support/index.js";
-export { ThreadMemorySync } from "./thread-memory-sync.js";
+export { ThreadMemorySync } from "./harness/system/thread-memory-sync.js";
 export type { HarnessEventListener, HarnessEventProjection, RuntimeEventSink } from "../contracts/types.js";

package/dist/runtime/index.js

@@ -1,14 +1,14 @@
 export { AgentRuntimeAdapter, AGENT_INTERRUPT_SENTINEL_PREFIX } from "./agent-runtime-adapter.js";
-export { EventBus } from "./event-bus.js";
-export { createRuntimeEventSink, RuntimeEventSinkImpl } from "./event-sink.js";
+export { EventBus } from "./harness/events/event-bus.js";
+export { createRuntimeEventSink, RuntimeEventSinkImpl } from "./harness/events/event-sink.js";
 export { FileCheckpointSaver } from "./file-checkpoint-saver.js";
 export { CheckpointMaintenanceLoop, discoverCheckpointMaintenanceTargets, maintainSqliteCheckpoints, readCheckpointMaintenanceConfig, } from "./checkpoint-maintenance.js";
 export { ManagedSqliteSaver } from "./sqlite-maintained-checkpoint-saver.js";
 export { AgentHarnessRuntime, AgentHarness } from "./harness.js";
-export { describeWorkspaceInventory, findAgentBinding, listAgentSkills, listAgentTools, listAvailableAgents, listSpecialists, } from "./inventory.js";
-export { assessOpenClawRequirements, assessSkillRequirements, } from "./skill-requirements.js";
+export { describeWorkspaceInventory, findAgentBinding, listAgentSkills, listAgentTools, listAvailableAgents, listSpecialists, } from "./harness/system/inventory.js";
+export { assessOpenClawRequirements, assessSkillRequirements, } from "./harness/system/skill-requirements.js";
 export * from "./parsing/index.js";
-export { PolicyEngine } from "./policy-engine.js";
-export { createInMemoryStore, FileBackedStore } from "./store.js";
+export { PolicyEngine } from "./harness/system/policy-engine.js";
+export { createInMemoryStore, FileBackedStore } from "./harness/system/store.js";
 export * from "./support/index.js";
-export { ThreadMemorySync } from "./thread-memory-sync.js";
+export { ThreadMemorySync } from "./harness/system/thread-memory-sync.js";

package/dist/runtime/maintenance/checkpoint-maintenance.d.ts

@@ -0,0 +1,45 @@
+import type { WorkspaceBundle } from "../../contracts/types.js";
+type CheckpointMaintenanceConfig = {
+    enabled: boolean;
+    schedule: {
+        intervalSeconds: number;
+        runOnStartup: boolean;
+    };
+    policies: {
+        maxAgeSeconds?: number;
+        maxBytes?: number;
+    };
+    sqlite: {
+        sweepBatchSize: number;
+        vacuum: boolean;
+    };
+};
+type CheckpointMaintenanceTarget = {
+    agentId: string;
+    dbPath: string;
+};
+export type MaintenanceLoopStatus = {
+    lastStartedAt?: string;
+    lastCompletedAt?: string;
+    lastFailedAt?: string;
+    consecutiveFailures: number;
+    lastError?: string;
+};
+export declare function readCheckpointMaintenanceConfig(workspace: WorkspaceBundle): CheckpointMaintenanceConfig | null;
+export declare function discoverCheckpointMaintenanceTargets(workspace: WorkspaceBundle): CheckpointMaintenanceTarget[];
+export declare function maintainSqliteCheckpoints(dbPath: string, config: CheckpointMaintenanceConfig, nowMs?: number): Promise<{
+    deletedCount: number;
+}>;
+export declare class CheckpointMaintenanceLoop {
+    private readonly targets;
+    private readonly config;
+    private timer;
+    private running;
+    private status;
+    constructor(targets: CheckpointMaintenanceTarget[], config: CheckpointMaintenanceConfig);
+    runOnce(nowMs?: number): Promise<void>;
+    getStatus(): MaintenanceLoopStatus;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}
+export {};

package/dist/runtime/maintenance/checkpoint-maintenance.js

@@ -0,0 +1,259 @@
+import path from "node:path";
+import { SqliteSaver } from "@langchain/langgraph-checkpoint-sqlite";
+import { listProtectedCheckpointThreadIds } from "../../persistence/sqlite-store.js";
+import { fileExists } from "../../utils/fs.js";
+import { getRuntimeDefaults } from "../../workspace/support/workspace-ref-utils.js";
+import { ManagedSqliteSaver } from "./sqlite-maintained-checkpoint-saver.js";
+function asObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
+}
+function readPositiveNumber(value, label, allowUndefined = true) {
+    if (value === undefined && allowUndefined) {
+        return undefined;
+    }
+    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+        throw new Error(`${label} must be a positive number`);
+    }
+    return value;
+}
+export function readCheckpointMaintenanceConfig(workspace) {
+    const runtimeDefaults = getRuntimeDefaults(workspace.refs);
+    const maintenance = asObject(runtimeDefaults?.maintenance);
+    const checkpoints = asObject(maintenance?.checkpoints);
+    if (!checkpoints || checkpoints.enabled !== true) {
+        return null;
+    }
+    const schedule = asObject(checkpoints.schedule);
+    const policies = asObject(checkpoints.policies);
+    const sqlite = asObject(checkpoints.sqlite);
+    const config = {
+        enabled: true,
+        schedule: {
+            intervalSeconds: readPositiveNumber(schedule?.intervalSeconds, "runtime.maintenance.checkpoints.schedule.intervalSeconds") ?? 3600,
+            runOnStartup: schedule?.runOnStartup !== false,
+        },
+        policies: {
+            maxAgeSeconds: readPositiveNumber(policies?.maxAgeSeconds, "runtime.maintenance.checkpoints.policies.maxAgeSeconds"),
+            maxBytes: readPositiveNumber(policies?.maxBytes, "runtime.maintenance.checkpoints.policies.maxBytes"),
+        },
+        sqlite: {
+            sweepBatchSize: readPositiveNumber(sqlite?.sweepBatchSize, "runtime.maintenance.checkpoints.sqlite.sweepBatchSize") ?? 200,
+            vacuum: sqlite?.vacuum === true,
+        },
+    };
+    if (config.policies.maxAgeSeconds === undefined && config.policies.maxBytes === undefined) {
+        throw new Error("runtime.maintenance.checkpoints.enabled requires at least one cleanup policy");
+    }
+    return config;
+}
+function resolveSqliteCheckpointPath(binding) {
+    const config = binding.harnessRuntime.checkpointer;
+    if (!config || typeof config === "boolean") {
+        return null;
+    }
+    const kind = typeof config.kind === "string" ? config.kind : "FileCheckpointer";
+    if (kind !== "SqliteSaver") {
+        return null;
+    }
+    const configuredPath = typeof config.path === "string" ? String(config.path) : "checkpoints.sqlite";
+    return path.isAbsolute(configuredPath) ? configuredPath : path.join(binding.harnessRuntime.runRoot, configuredPath);
+}
+export function discoverCheckpointMaintenanceTargets(workspace) {
+    const deduped = new Map();
+    for (const binding of workspace.bindings.values()) {
+        const dbPath = resolveSqliteCheckpointPath(binding);
+        if (!dbPath) {
+            continue;
+        }
+        deduped.set(dbPath, {
+            agentId: binding.agent.id,
+            dbPath,
+        });
+    }
+    return Array.from(deduped.values());
+}
+function backfillCheckpointMetadata(db, nowMs = Date.now()) {
+    db.exec(`
+CREATE TABLE IF NOT EXISTS checkpoint_maintenance_meta (
+  thread_id TEXT NOT NULL,
+  checkpoint_ns TEXT NOT NULL DEFAULT '',
+  checkpoint_id TEXT NOT NULL,
+  created_at_ms INTEGER NOT NULL,
+  PRIMARY KEY (thread_id, checkpoint_ns, checkpoint_id)
+);`);
+    db.prepare(`INSERT OR IGNORE INTO checkpoint_maintenance_meta
+     (thread_id, checkpoint_ns, checkpoint_id, created_at_ms)
+     SELECT thread_id, checkpoint_ns, checkpoint_id, ?
+     FROM checkpoints`).run(nowMs);
+}
+function deleteCheckpointRows(db, rows) {
+    if (rows.length === 0) {
+        return 0;
+    }
+    const deleteCheckpoint = db.prepare(`DELETE FROM checkpoints
+     WHERE thread_id = ? AND checkpoint_ns = ? AND checkpoint_id = ?`);
+    const deleteWrites = db.prepare(`DELETE FROM writes
+     WHERE thread_id = ? AND checkpoint_ns = ? AND checkpoint_id = ?`);
+    const deleteMeta = db.prepare(`DELETE FROM checkpoint_maintenance_meta
+     WHERE thread_id = ? AND checkpoint_ns = ? AND checkpoint_id = ?`);
+    db.transaction((items) => {
+        for (const row of items) {
+            deleteCheckpoint.run(row.thread_id, row.checkpoint_ns, row.checkpoint_id);
+            deleteWrites.run(row.thread_id, row.checkpoint_ns, row.checkpoint_id);
+            deleteMeta.run(row.thread_id, row.checkpoint_ns, row.checkpoint_id);
+        }
+    })(rows);
+    return rows.length;
+}
+function selectOldestRows(db, limit) {
+    return db
+        .prepare(`SELECT
+         meta.thread_id,
+         meta.checkpoint_ns,
+         meta.checkpoint_id,
+         meta.created_at_ms,
+         COALESCE(LENGTH(cp.checkpoint), 0) + COALESCE(LENGTH(cp.metadata), 0) + COALESCE(SUM(LENGTH(w.value)), 0) AS size_bytes
+       FROM checkpoint_maintenance_meta AS meta
+       JOIN checkpoints AS cp
+         ON cp.thread_id = meta.thread_id
+        AND cp.checkpoint_ns = meta.checkpoint_ns
+        AND cp.checkpoint_id = meta.checkpoint_id
+       LEFT JOIN writes AS w
+         ON w.thread_id = meta.thread_id
+        AND w.checkpoint_ns = meta.checkpoint_ns
+        AND w.checkpoint_id = meta.checkpoint_id
+       GROUP BY meta.thread_id, meta.checkpoint_ns, meta.checkpoint_id, meta.created_at_ms, cp.checkpoint, cp.metadata
+       ORDER BY meta.created_at_ms ASC, meta.checkpoint_id ASC
+       LIMIT ?`)
+        .all(limit);
+}
+function totalCheckpointBytes(db) {
+    const checkpointsBytes = db
+        .prepare(`SELECT COALESCE(SUM(LENGTH(checkpoint) + LENGTH(metadata)), 0) AS total FROM checkpoints`)
+        .get();
+    const writesBytes = db
+        .prepare(`SELECT COALESCE(SUM(LENGTH(value)), 0) AS total FROM writes`)
+        .get();
+    return Number(checkpointsBytes.total ?? 0) + Number(writesBytes.total ?? 0);
+}
+export function maintainSqliteCheckpoints(dbPath, config, nowMs = Date.now()) {
+    return maintainSqliteCheckpointsInternal(dbPath, config, nowMs);
+}
+async function maintainSqliteCheckpointsInternal(dbPath, config, nowMs) {
+    if (!(await fileExists(dbPath))) {
+        return { deletedCount: 0 };
+    }
+    const saver = new ManagedSqliteSaver(SqliteSaver.fromConnString(dbPath).db);
+    const db = saver.db;
+    try {
+        saver.prepareMaintenance();
+        backfillCheckpointMetadata(db, nowMs);
+        const protectedThreadIds = await listProtectedCheckpointThreadIds(path.join(path.dirname(dbPath), "runtime.sqlite"));
+        let deletedCount = 0;
+        if (config.policies.maxAgeSeconds !== undefined) {
+            const cutoffMs = nowMs - config.policies.maxAgeSeconds * 1000;
+            const expired = db
+                .prepare(`SELECT
+             meta.thread_id,
+             meta.checkpoint_ns,
+             meta.checkpoint_id,
+             meta.created_at_ms,
+             0 AS size_bytes
+           FROM checkpoint_maintenance_meta AS meta
+           WHERE meta.created_at_ms <= ?
+           ORDER BY meta.created_at_ms ASC, meta.checkpoint_id ASC
+           LIMIT ?`)
+                .all(cutoffMs, config.sqlite.sweepBatchSize * 4);
+            deletedCount += deleteCheckpointRows(db, expired.filter((row) => !protectedThreadIds.has(row.thread_id)).slice(0, config.sqlite.sweepBatchSize));
+        }
+        if (config.policies.maxBytes !== undefined) {
+            let currentBytes = totalCheckpointBytes(db);
+            while (currentBytes > config.policies.maxBytes) {
+                const oldest = selectOldestRows(db, config.sqlite.sweepBatchSize * 4).filter((row) => !protectedThreadIds.has(row.thread_id));
+                if (oldest.length === 0) {
+                    break;
+                }
+                let reclaimed = 0;
+                const toDelete = [];
+                for (const row of oldest) {
+                    toDelete.push(row);
+                    reclaimed += Number(row.size_bytes ?? 0);
+                    if (currentBytes - reclaimed <= config.policies.maxBytes) {
+                        break;
+                    }
+                }
+                deletedCount += deleteCheckpointRows(db, toDelete);
+                currentBytes = totalCheckpointBytes(db);
+            }
+        }
+        if (deletedCount > 0 && config.sqlite.vacuum) {
+            db.exec("VACUUM");
+        }
+        return { deletedCount };
+    }
+    finally {
+        db.close();
+    }
+}
+export class CheckpointMaintenanceLoop {
+    targets;
+    config;
+    timer = null;
+    running = false;
+    status = {
+        consecutiveFailures: 0,
+    };
+    constructor(targets, config) {
+        this.targets = targets;
+        this.config = config;
+    }
+    async runOnce(nowMs = Date.now()) {
+        this.status = {
+            ...this.status,
+            lastStartedAt: new Date(nowMs).toISOString(),
+        };
+        try {
+            for (const target of this.targets) {
+                await maintainSqliteCheckpoints(target.dbPath, this.config, nowMs);
+            }
+            this.status = {
+                ...this.status,
+                lastCompletedAt: new Date(nowMs).toISOString(),
+                consecutiveFailures: 0,
+                lastError: undefined,
+            };
+        }
+        catch (error) {
+            this.status = {
+                ...this.status,
+                lastFailedAt: new Date(nowMs).toISOString(),
+                consecutiveFailures: this.status.consecutiveFailures + 1,
+                lastError: error instanceof Error ? error.message : String(error),
+            };
+            throw error;
+        }
+    }
+    getStatus() {
+        return { ...this.status };
+    }
+    async start() {
+        if (this.running) {
+            return;
+        }
+        this.running = true;
+        if (this.config.schedule.runOnStartup) {
+            await this.runOnce();
+        }
+        this.timer = setInterval(() => {
+            void this.runOnce();
+        }, this.config.schedule.intervalSeconds * 1000);
+        this.timer.unref?.();
+    }
+    async stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        this.running = false;
+    }
+}

package/dist/runtime/maintenance/file-checkpoint-saver.d.ts

@@ -0,0 +1,20 @@
+import { MemorySaver } from "@langchain/langgraph";
+type MemorySaverConfig = Parameters<MemorySaver["getTuple"]>[0];
+type MemorySaverListOptions = Parameters<MemorySaver["list"]>[1];
+type MemorySaverPutCheckpoint = Parameters<MemorySaver["put"]>[1];
+type MemorySaverPutMetadata = Parameters<MemorySaver["put"]>[2];
+type MemorySaverPutWrites = Parameters<MemorySaver["putWrites"]>[1];
+type MemorySaverPutResult = ReturnType<MemorySaver["put"]>;
+export declare class FileCheckpointSaver extends MemorySaver {
+    private readonly filePath;
+    private loaded;
+    constructor(filePath: string);
+    private ensureLoaded;
+    private persist;
+    getTuple(config: MemorySaverConfig): Promise<import("@langchain/langgraph").CheckpointTuple | undefined>;
+    list(config: MemorySaverConfig, options?: MemorySaverListOptions): AsyncGenerator<import("@langchain/langgraph").CheckpointTuple, void, unknown>;
+    put(config: MemorySaverConfig, checkpoint: MemorySaverPutCheckpoint, metadata: MemorySaverPutMetadata): MemorySaverPutResult;
+    putWrites(config: MemorySaverConfig, writes: MemorySaverPutWrites, taskId: string): Promise<void>;
+    deleteThread(threadId: string): Promise<void>;
+}
+export { FileCheckpointSaver as FileCheckpointer };

package/dist/runtime/maintenance/file-checkpoint-saver.js

@@ -0,0 +1,106 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { MemorySaver } from "@langchain/langgraph";
+function encodeBinary(value) {
+    if (value instanceof Uint8Array) {
+        return {
+            __type: "Uint8Array",
+            data: Array.from(value),
+        };
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => encodeBinary(item));
+    }
+    if (typeof value === "object" && value) {
+        return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, encodeBinary(entry)]));
+    }
+    return value;
+}
+function decodeBinary(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => decodeBinary(item));
+    }
+    if (typeof value === "object" && value) {
+        const typed = value;
+        if (typed.__type === "Uint8Array" && Array.isArray(typed.data)) {
+            return new Uint8Array(typed.data.map((item) => Number(item)));
+        }
+        return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, decodeBinary(entry)]));
+    }
+    return value;
+}
+function pruneThreadEntries(record, threadId) {
+    for (const key of Object.keys(record)) {
+        if (key.includes(threadId)) {
+            delete record[key];
+            continue;
+        }
+        const value = record[key];
+        if (typeof value === "object" && value && !Array.isArray(value)) {
+            pruneThreadEntries(value, threadId);
+            if (Object.keys(value).length === 0) {
+                delete record[key];
+            }
+        }
+    }
+}
+export class FileCheckpointSaver extends MemorySaver {
+    filePath;
+    loaded = false;
+    constructor(filePath) {
+        super();
+        this.filePath = filePath;
+    }
+    async ensureLoaded() {
+        if (this.loaded) {
+            return;
+        }
+        try {
+            const raw = await readFile(this.filePath, "utf8");
+            const parsed = JSON.parse(raw);
+            this.storage = decodeBinary(parsed.storage ?? {});
+            this.writes = decodeBinary(parsed.writes ?? {});
+        }
+        catch {
+            this.storage = {};
+            this.writes = {};
+        }
+        this.loaded = true;
+    }
+    async persist() {
+        await mkdir(path.dirname(this.filePath), { recursive: true });
+        await writeFile(this.filePath, JSON.stringify({
+            storage: this.storage,
+            writes: this.writes,
+        }, (_, value) => encodeBinary(value), 2), "utf8");
+    }
+    async getTuple(config) {
+        await this.ensureLoaded();
+        return super.getTuple(config);
+    }
+    async *list(config, options) {
+        await this.ensureLoaded();
+        for await (const item of super.list(config, options)) {
+            yield item;
+        }
+    }
+    async put(config, checkpoint, metadata) {
+        await this.ensureLoaded();
+        const result = await super.put(config, checkpoint, metadata);
+        await this.persist();
+        return result;
+    }
+    async putWrites(config, writes, taskId) {
+        await this.ensureLoaded();
+        const result = await super.putWrites(config, writes, taskId);
+        await this.persist();
+        return result;
+    }
+    async deleteThread(threadId) {
+        await this.ensureLoaded();
+        pruneThreadEntries(this.storage, threadId);
+        pruneThreadEntries(this.writes, threadId);
+        await this.persist();
+    }
+}
+export { FileCheckpointSaver as FileCheckpointer };

package/dist/runtime/maintenance/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./checkpoint-maintenance.js";
+export * from "./file-checkpoint-saver.js";
+export * from "./runtime-record-maintenance.js";
+export * from "./sqlite-maintained-checkpoint-saver.js";

package/dist/runtime/maintenance/index.js

@@ -0,0 +1,4 @@
+export * from "./checkpoint-maintenance.js";
+export * from "./file-checkpoint-saver.js";
+export * from "./runtime-record-maintenance.js";
+export * from "./sqlite-maintained-checkpoint-saver.js";

package/dist/runtime/{runtime-record-maintenance.d.ts → maintenance/runtime-record-maintenance.d.ts}

@@ -1,4 +1,4 @@
-import type { WorkspaceBundle } from "../contracts/types.js";
+import type { WorkspaceBundle } from "../../contracts/types.js";
 type RuntimeRecordMaintenanceConfig = {
     enabled: boolean;
     schedule: {

package/dist/runtime/{runtime-record-maintenance.js → maintenance/runtime-record-maintenance.js}

@@ -1,8 +1,8 @@
 import path from "node:path";
 import { rm } from "node:fs/promises";
 import { createClient } from "@libsql/client";
-import { fileExists } from "../utils/fs.js";
-import { getRuntimeDefaults } from "../workspace/support/workspace-ref-utils.js";
+import { fileExists } from "../../utils/fs.js";
+import { getRuntimeDefaults } from "../../workspace/support/workspace-ref-utils.js";
 function asObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
 }

package/dist/runtime/maintenance/sqlite-maintained-checkpoint-saver.d.ts

@@ -0,0 +1,9 @@
+import { SqliteSaver } from "@langchain/langgraph-checkpoint-sqlite";
+import type { RunnableConfig } from "@langchain/core/runnables";
+export declare class ManagedSqliteSaver extends SqliteSaver {
+    constructor(db: ConstructorParameters<typeof SqliteSaver>[0]);
+    prepareMaintenance(): void;
+    setup(): void;
+    put(config: RunnableConfig, checkpoint: Parameters<SqliteSaver["put"]>[1], metadata: Parameters<SqliteSaver["put"]>[2]): Promise<RunnableConfig<Record<string, any>>>;
+    deleteThread(threadId: string): Promise<void>;
+}

package/dist/runtime/maintenance/sqlite-maintained-checkpoint-saver.js

@@ -0,0 +1,39 @@
+import { SqliteSaver } from "@langchain/langgraph-checkpoint-sqlite";
+export class ManagedSqliteSaver extends SqliteSaver {
+    constructor(db) {
+        super(db);
+    }
+    prepareMaintenance() {
+        this.setup();
+    }
+    setup() {
+        super.setup();
+        this.db.exec(`
+CREATE TABLE IF NOT EXISTS checkpoint_maintenance_meta (
+  thread_id TEXT NOT NULL,
+  checkpoint_ns TEXT NOT NULL DEFAULT '',
+  checkpoint_id TEXT NOT NULL,
+  created_at_ms INTEGER NOT NULL,
+  PRIMARY KEY (thread_id, checkpoint_ns, checkpoint_id)
+);`);
+    }
+    async put(config, checkpoint, metadata) {
+        const result = await super.put(config, checkpoint, metadata);
+        const threadId = result.configurable?.thread_id;
+        const checkpointNs = result.configurable?.checkpoint_ns ?? "";
+        const checkpointId = result.configurable?.checkpoint_id;
+        if (!threadId || !checkpointId) {
+            throw new Error("Missing checkpoint identity after SqliteSaver.put");
+        }
+        this.db
+            .prepare(`INSERT OR IGNORE INTO checkpoint_maintenance_meta
+         (thread_id, checkpoint_ns, checkpoint_id, created_at_ms)
+         VALUES (?, ?, ?, ?)`)
+            .run(threadId, checkpointNs, checkpointId, Date.now());
+        return result;
+    }
+    async deleteThread(threadId) {
+        await super.deleteThread(threadId);
+        this.db.prepare(`DELETE FROM checkpoint_maintenance_meta WHERE thread_id = ?`).run(threadId);
+    }
+}

package/dist/runtime/sqlite-maintained-checkpoint-saver.d.ts

@@ -1,9 +1 @@
-import { SqliteSaver } from "@langchain/langgraph-checkpoint-sqlite";
-import type { RunnableConfig } from "@langchain/core/runnables";
-export declare class ManagedSqliteSaver extends SqliteSaver {
-    constructor(db: ConstructorParameters<typeof SqliteSaver>[0]);
-    prepareMaintenance(): void;
-    setup(): void;
-    put(config: RunnableConfig, checkpoint: Parameters<SqliteSaver["put"]>[1], metadata: Parameters<SqliteSaver["put"]>[2]): Promise<RunnableConfig<Record<string, any>>>;
-    deleteThread(threadId: string): Promise<void>;
-}
+export * from "./maintenance/sqlite-maintained-checkpoint-saver.js";

package/dist/runtime/sqlite-maintained-checkpoint-saver.js

@@ -1,39 +1 @@
-import { SqliteSaver } from "@langchain/langgraph-checkpoint-sqlite";
-export class ManagedSqliteSaver extends SqliteSaver {
-    constructor(db) {
-        super(db);
-    }
-    prepareMaintenance() {
-        this.setup();
-    }
-    setup() {
-        super.setup();
-        this.db.exec(`
-CREATE TABLE IF NOT EXISTS checkpoint_maintenance_meta (
-  thread_id TEXT NOT NULL,
-  checkpoint_ns TEXT NOT NULL DEFAULT '',
-  checkpoint_id TEXT NOT NULL,
-  created_at_ms INTEGER NOT NULL,
-  PRIMARY KEY (thread_id, checkpoint_ns, checkpoint_id)
-);`);
-    }
-    async put(config, checkpoint, metadata) {
-        const result = await super.put(config, checkpoint, metadata);
-        const threadId = result.configurable?.thread_id;
-        const checkpointNs = result.configurable?.checkpoint_ns ?? "";
-        const checkpointId = result.configurable?.checkpoint_id;
-        if (!threadId || !checkpointId) {
-            throw new Error("Missing checkpoint identity after SqliteSaver.put");
-        }
-        this.db
-            .prepare(`INSERT OR IGNORE INTO checkpoint_maintenance_meta
-         (thread_id, checkpoint_ns, checkpoint_id, created_at_ms)
-         VALUES (?, ?, ?, ?)`)
-            .run(threadId, checkpointNs, checkpointId, Date.now());
-        return result;
-    }
-    async deleteThread(threadId) {
-        await super.deleteThread(threadId);
-        this.db.prepare(`DELETE FROM checkpoint_maintenance_meta WHERE thread_id = ?`).run(threadId);
-    }
-}
+export * from "./maintenance/sqlite-maintained-checkpoint-saver.js";

package/dist/runtime/support/harness-support.d.ts

@@ -21,8 +21,8 @@ export declare function heuristicRoute(input: string, primaryBinding?: {
 export declare function createHarnessEvent(threadId: string, runId: string, sequence: number, eventType: string, payload: Record<string, unknown>, source?: HarnessEvent["source"]): HarnessEvent;
 export declare function createPendingApproval(threadId: string, runId: string, checkpointRef: string, input: string, interruptContent?: string): InternalApprovalRecord;
 export declare function inferRoutingBindings(workspace: WorkspaceBundle): {
-    primaryBinding: import("../../contracts/types.js").CompiledAgentBinding;
-    secondaryBinding: import("../../contracts/types.js").CompiledAgentBinding | undefined;
-    researchBinding: import("../../contracts/types.js").CompiledAgentBinding | undefined;
-    hostBindings: import("../../contracts/types.js").CompiledAgentBinding[];
+    primaryBinding: import("../../contracts/workspace.js").CompiledAgentBinding;
+    secondaryBinding: import("../../contracts/workspace.js").CompiledAgentBinding | undefined;
+    researchBinding: import("../../contracts/workspace.js").CompiledAgentBinding | undefined;
+    hostBindings: import("../../contracts/workspace.js").CompiledAgentBinding[];
 };

package/dist/runtime/support/runtime-factories.d.ts

@@ -1,3 +1,3 @@
-import { type StoreLike } from "../store.js";
+import { type StoreLike } from "../harness/system/store.js";
 export declare function createStoreForConfig(storeConfig: Record<string, unknown>, runRoot: string): StoreLike;
 export declare function createCheckpointerForConfig(checkpointerConfig: Record<string, unknown> | boolean, runRoot: string): unknown;

package/dist/runtime/support/runtime-factories.js

@@ -3,7 +3,7 @@ import { MemorySaver } from "@langchain/langgraph";
 import { SqliteSaver } from "@langchain/langgraph-checkpoint-sqlite";
 import { FileCheckpointSaver } from "../file-checkpoint-saver.js";
 import { ManagedSqliteSaver } from "../sqlite-maintained-checkpoint-saver.js";
-import { createInMemoryStore, FileBackedStore } from "../store.js";
+import { createInMemoryStore, FileBackedStore } from "../harness/system/store.js";
 export function createStoreForConfig(storeConfig, runRoot) {
     const kind = typeof storeConfig.kind === "string" ? storeConfig.kind : "FileStore";
     switch (kind) {