@elizaos/agent 2.0.0-alpha.441 → 2.0.0-alpha.501

package/packages/agent/src/runtime/operations/manager.d.ts

@@ -0,0 +1,68 @@
+/**
+ * DefaultRuntimeOperationManager — the single use case for state-changing
+ * lifecycle actions against the live runtime.
+ *
+ * Lifecycle:
+ *   1. Caller (route layer) hands us an OperationIntent (already validated).
+ *   2. We classify the intent into a ReloadTier.
+ *   3. If an op is already active we reject with `rejected-busy`. If an
+ *      idempotency key matches a record within retention we return
+ *      `deduped`. Otherwise we accept synchronously and run the op
+ *      asynchronously on the next microtask.
+ *   4. Each phase mutation is appended to the repo. The repo's active-op
+ *      slot is the single-flight gate; no extra in-memory mutex is used
+ *      across operations, but the manager serializes its own
+ *      `executeOperation` calls via a Promise chain.
+ */
+import type { AgentRuntime } from "@elizaos/core";
+import type { ClassifyContext } from "./classifier.js";
+import type { HealthChecker } from "./health.js";
+import type { OperationIntent, ReloadStrategy, ReloadTier, RuntimeOperation, RuntimeOperationListOptions, RuntimeOperationManager, RuntimeOperationRepository, StartOperationOutcome, StartOperationRequest } from "./types.js";
+export type IntentClassifier = (intent: OperationIntent, ctx: ClassifyContext) => ReloadTier;
+export interface DefaultRuntimeOperationManagerOptions {
+    repository: RuntimeOperationRepository;
+    /**
+     * Resolves the *current* live runtime. Called per-operation so the
+     * manager always sees the latest reference (cold ops swap it).
+     */
+    runtime: () => AgentRuntime | null;
+    /**
+     * Snapshots the live config slice the classifier needs. Called once per
+     * `start()` so the classifier sees the state at submission time, not at
+     * execution time (which may be after another op completes).
+     */
+    classifyContext: () => ClassifyContext;
+    /**
+     * Defaults to `() => "cold"` (conservative). Wire `defaultClassifier`
+     * from `./classifier.js` to enable hot/warm tiering.
+     */
+    classifier?: IntentClassifier;
+    healthChecker: HealthChecker;
+    /**
+     * Tier → strategy. The cold strategy is required for Phase 1; warm/hot
+     * are optional and added by sibling agents.
+     */
+    strategies: Partial<Record<ReloadTier, ReloadStrategy>>;
+}
+export declare class DefaultRuntimeOperationManager implements RuntimeOperationManager {
+    private readonly repository;
+    private readonly runtime;
+    private readonly classifyContext;
+    private readonly classifier;
+    private readonly healthChecker;
+    private readonly strategies;
+    /**
+     * Serializes `executeOperation` invocations within a single process.
+     * The repo's active-op slot is the cross-process gate.
+     */
+    private executionChain;
+    constructor(opts: DefaultRuntimeOperationManagerOptions);
+    start(req: StartOperationRequest): Promise<StartOperationOutcome>;
+    get(id: string): Promise<RuntimeOperation | null>;
+    list(opts?: RuntimeOperationListOptions): Promise<RuntimeOperation[]>;
+    findActive(): Promise<RuntimeOperation | null>;
+    private scheduleExecution;
+    private executeOperation;
+    private failOperation;
+}
+//# sourceMappingURL=manager.d.ts.map

package/packages/agent/src/runtime/operations/manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../../../../../../src/runtime/operations/manager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAElD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,KAAK,EACV,eAAe,EAEf,cAAc,EACd,UAAU,EACV,gBAAgB,EAChB,2BAA2B,EAC3B,uBAAuB,EACvB,0BAA0B,EAC1B,qBAAqB,EACrB,qBAAqB,EACtB,MAAM,YAAY,CAAC;AAEpB,MAAM,MAAM,gBAAgB,GAAG,CAC7B,MAAM,EAAE,eAAe,EACvB,GAAG,EAAE,eAAe,KACjB,UAAU,CAAC;AAEhB,MAAM,WAAW,qCAAqC;IACpD,UAAU,EAAE,0BAA0B,CAAC;IACvC;;;OAGG;IACH,OAAO,EAAE,MAAM,YAAY,GAAG,IAAI,CAAC;IACnC;;;;OAIG;IACH,eAAe,EAAE,MAAM,eAAe,CAAC;IACvC;;;OAGG;IACH,UAAU,CAAC,EAAE,gBAAgB,CAAC;IAC9B,aAAa,EAAE,aAAa,CAAC;IAC7B;;;OAGG;IACH,UAAU,EAAE,OAAO,CAAC,MAAM,CAAC,UAAU,EAAE,cAAc,CAAC,CAAC,CAAC;CACzD;AAID,qBAAa,8BAA+B,YAAW,uBAAuB;IAC5E,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA6B;IACxD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA4B;IACpD,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAwB;IACxD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAmB;IAC9C,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAgB;IAC9C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA8C;IACzE;;;OAGG;IACH,OAAO,CAAC,cAAc,CAAoC;gBAE9C,IAAI,EAAE,qCAAqC;IASjD,KAAK,CAAC,GAAG,EAAE,qBAAqB,GAAG,OAAO,CAAC,qBAAqB,CAAC;IA8CjE,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC;IAIjD,IAAI,CAAC,IAAI,CAAC,EAAE,2BAA2B,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC;IAIrE,UAAU,IAAI,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC;IAIpD,OAAO,CAAC,iBAAiB;YAUX,gBAAgB;YAsGhB,aAAa;CAa5B"}

package/packages/agent/src/runtime/operations/manager.js

@@ -0,0 +1,182 @@
+/**
+ * DefaultRuntimeOperationManager — the single use case for state-changing
+ * lifecycle actions against the live runtime.
+ *
+ * Lifecycle:
+ *   1. Caller (route layer) hands us an OperationIntent (already validated).
+ *   2. We classify the intent into a ReloadTier.
+ *   3. If an op is already active we reject with `rejected-busy`. If an
+ *      idempotency key matches a record within retention we return
+ *      `deduped`. Otherwise we accept synchronously and run the op
+ *      asynchronously on the next microtask.
+ *   4. Each phase mutation is appended to the repo. The repo's active-op
+ *      slot is the single-flight gate; no extra in-memory mutex is used
+ *      across operations, but the manager serializes its own
+ *      `executeOperation` calls via a Promise chain.
+ */
+import crypto from "node:crypto";
+import { logger } from "@elizaos/core";
+const DEFAULT_CLASSIFIER = () => "cold";
+export class DefaultRuntimeOperationManager {
+    repository;
+    runtime;
+    classifyContext;
+    classifier;
+    healthChecker;
+    strategies;
+    /**
+     * Serializes `executeOperation` invocations within a single process.
+     * The repo's active-op slot is the cross-process gate.
+     */
+    executionChain = Promise.resolve();
+    constructor(opts) {
+        this.repository = opts.repository;
+        this.runtime = opts.runtime;
+        this.classifyContext = opts.classifyContext;
+        this.classifier = opts.classifier ?? DEFAULT_CLASSIFIER;
+        this.healthChecker = opts.healthChecker;
+        this.strategies = opts.strategies;
+    }
+    async start(req) {
+        if (req.idempotencyKey) {
+            const existing = await this.repository.findByIdempotencyKey(req.idempotencyKey);
+            if (existing) {
+                logger.info(`[runtime-ops] Idempotent hit for key=${req.idempotencyKey} → ${existing.id}`);
+                return { kind: "deduped", operation: existing };
+            }
+        }
+        const active = await this.repository.findActive();
+        if (active) {
+            logger.info(`[runtime-ops] Rejected new op: active operation in flight ${active.id}`);
+            return { kind: "rejected-busy", activeOperationId: active.id };
+        }
+        const tier = this.classifier(req.intent, this.classifyContext());
+        const now = Date.now();
+        const op = {
+            id: crypto.randomUUID(),
+            kind: req.intent.kind,
+            intent: req.intent,
+            tier,
+            idempotencyKey: req.idempotencyKey,
+            status: "pending",
+            phases: [],
+            startedAt: now,
+        };
+        await this.repository.create(op);
+        logger.info(`[runtime-ops] Accepted op ${op.id} kind=${op.kind} tier=${op.tier}`);
+        // Schedule async; do NOT await. The route caller returns 202
+        // immediately and the client polls /events for status.
+        this.scheduleExecution(op.id);
+        return { kind: "accepted", operation: op };
+    }
+    async get(id) {
+        return this.repository.get(id);
+    }
+    async list(opts) {
+        return this.repository.list(opts);
+    }
+    async findActive() {
+        return this.repository.findActive();
+    }
+    scheduleExecution(id) {
+        this.executionChain = this.executionChain.then(() => this.executeOperation(id).catch((err) => {
+            logger.error(`[runtime-ops] Unhandled error executing op ${id}: ${err instanceof Error ? err.stack : String(err)}`);
+        }));
+    }
+    async executeOperation(id) {
+        const op = await this.repository.get(id);
+        if (!op) {
+            logger.warn(`[runtime-ops] executeOperation: op ${id} not found`);
+            return;
+        }
+        await this.repository.update(id, { status: "running" });
+        // Phase: validate (the route layer already validated; this records the
+        // gate boundary so the phase log is complete).
+        const validateAt = Date.now();
+        await this.repository.appendPhase(id, {
+            name: "validate",
+            status: "succeeded",
+            startedAt: validateAt,
+            finishedAt: validateAt,
+        });
+        const strategy = this.strategies[op.tier];
+        if (!strategy) {
+            await this.failOperation(id, {
+                message: `No strategy registered for tier=${op.tier}`,
+                code: "no-strategy-for-tier",
+            });
+            return;
+        }
+        const runtime = this.runtime();
+        if (!runtime) {
+            await this.failOperation(id, {
+                message: "No live runtime available to apply operation",
+                code: "no-runtime",
+            });
+            return;
+        }
+        const reportPhase = (phase) => this.repository.appendPhase(id, phase);
+        let newRuntime;
+        try {
+            newRuntime = await strategy.apply({
+                runtime,
+                intent: op.intent,
+                reportPhase,
+            });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            logger.warn(`[runtime-ops] Strategy failed for op ${id}: ${message}`);
+            await this.failOperation(id, { message, code: "strategy-failed" });
+            return;
+        }
+        // Phase: health-check.
+        const healthStart = Date.now();
+        await this.repository.appendPhase(id, {
+            name: "health-check",
+            status: "running",
+            startedAt: healthStart,
+        });
+        const report = await this.healthChecker.runForRuntime(newRuntime);
+        const healthEnd = Date.now();
+        if (!report.ok) {
+            await this.repository.updateLastPhase(id, {
+                status: "failed",
+                finishedAt: healthEnd,
+                detail: {
+                    passed: report.passed,
+                    failed: report.failed,
+                },
+            });
+            // Phase 2: real rollback. For Phase 1 the swap has already happened
+            // via the cold strategy; we record the failure and surface it.
+            logger.warn(`[runtime-ops] Health check failed for op ${id}; rollback deferred to Phase 2`);
+            await this.failOperation(id, {
+                message: "Required health checks failed",
+                code: "health-check-failed",
+            });
+            return;
+        }
+        await this.repository.updateLastPhase(id, {
+            status: "succeeded",
+            finishedAt: healthEnd,
+            detail: {
+                passed: report.passed,
+                failed: report.failed,
+            },
+        });
+        await this.repository.update(id, {
+            status: "succeeded",
+            finishedAt: Date.now(),
+        });
+        logger.info(`[runtime-ops] Operation ${id} succeeded`);
+    }
+    async failOperation(id, error) {
+        await this.repository.update(id, {
+            status: "failed",
+            finishedAt: Date.now(),
+            error,
+        });
+        logger.warn(`[runtime-ops] Operation ${id} failed: ${error.code ?? "unknown"} — ${error.message}`);
+    }
+}

package/packages/agent/src/runtime/operations/reload-hot.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Hot reload strategy.
+ *
+ * The fast path. Used when the change can be applied by mutating env vars and
+ * (best-effort) notifying plugins via their `applyConfig` lifecycle hook —
+ * no plugin reload, no service teardown, no full runtime swap.
+ *
+ * Bounded ~100ms. Idempotent: calling twice with the same intent is safe;
+ * env vars settle to the same values, notifications are best-effort.
+ *
+ * The strategy delegates env mutation to a caller-supplied `applyProviderEnv`
+ * which wraps the existing onboarding env-pump (`applyOnboardingConnectionConfig`
+ * + `createProviderSwitchConnection`). The plugin notify step iterates the
+ * runtime's plugins and invokes `plugin.applyConfig` when present; that hook
+ * is the one defined on the elizaOS Plugin contract for config-only updates.
+ */
+import type { AgentRuntime } from "@elizaos/core";
+import type { ProviderSwitchIntent, ReloadStrategy } from "./types.js";
+export interface HotStrategyDeps {
+    /**
+     * Apply env-var / config mutations for a provider switch. Defaults wrap the
+     * existing onboarding env-pump. The wrapper must be idempotent: same intent
+     * in → same env state out.
+     */
+    applyProviderEnv: (intent: ProviderSwitchIntent) => Promise<void>;
+    /**
+     * Best-effort plugin notify. Called after env mutation. Implementations
+     * iterate `runtime.plugins` and call each plugin's `applyConfig` hook (the
+     * elizaOS Plugin contract's config-only update path). Failures here are
+     * logged and surfaced as a warning phase, but do NOT fail the operation —
+     * env was already applied and plugins will pick up the new values on
+     * their next request.
+     */
+    notifyConfigChanged: (runtime: AgentRuntime, change: {
+        kind: string;
+        detail?: Record<string, unknown>;
+    }) => Promise<void>;
+}
+export declare function createHotStrategy(opts?: Partial<HotStrategyDeps>): ReloadStrategy;
+//# sourceMappingURL=reload-hot.d.ts.map

package/packages/agent/src/runtime/operations/reload-hot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reload-hot.d.ts","sourceRoot":"","sources":["../../../../../../src/runtime/operations/reload-hot.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAU,MAAM,eAAe,CAAC;AAE1D,OAAO,KAAK,EAGV,oBAAoB,EAEpB,cAAc,EACf,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,gBAAgB,EAAE,CAAC,MAAM,EAAE,oBAAoB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAClE;;;;;;;OAOG;IACH,mBAAmB,EAAE,CACnB,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,KACvD,OAAO,CAAC,IAAI,CAAC,CAAC;CACpB;AA6ID,wBAAgB,iBAAiB,CAC/B,IAAI,GAAE,OAAO,CAAC,eAAe,CAAM,GAClC,cAAc,CAiEhB"}

package/packages/agent/src/runtime/operations/reload-hot.js

@@ -0,0 +1,176 @@
+/**
+ * Hot reload strategy.
+ *
+ * The fast path. Used when the change can be applied by mutating env vars and
+ * (best-effort) notifying plugins via their `applyConfig` lifecycle hook —
+ * no plugin reload, no service teardown, no full runtime swap.
+ *
+ * Bounded ~100ms. Idempotent: calling twice with the same intent is safe;
+ * env vars settle to the same values, notifications are best-effort.
+ *
+ * The strategy delegates env mutation to a caller-supplied `applyProviderEnv`
+ * which wraps the existing onboarding env-pump (`applyOnboardingConnectionConfig`
+ * + `createProviderSwitchConnection`). The plugin notify step iterates the
+ * runtime's plugins and invokes `plugin.applyConfig` when present; that hook
+ * is the one defined on the elizaOS Plugin contract for config-only updates.
+ */
+import { logger } from "@elizaos/core";
+function nowMs() {
+    return Date.now();
+}
+function buildPhase(name, status, startedAt, finishedAt, extra = {}) {
+    return {
+        name,
+        status,
+        startedAt,
+        finishedAt,
+        ...(extra.error ? { error: extra.error } : {}),
+        ...(extra.detail ? { detail: extra.detail } : {}),
+    };
+}
+function describeIntent(intent) {
+    switch (intent.kind) {
+        case "provider-switch":
+            return {
+                kind: "provider-switch",
+                detail: {
+                    provider: intent.provider,
+                    ...(intent.primaryModel ? { primaryModel: intent.primaryModel } : {}),
+                    ...(intent.apiKey ? { apiKeyChanged: true } : {}),
+                },
+            };
+        case "config-reload":
+            return {
+                kind: "config-reload",
+                detail: {
+                    ...(intent.changedPaths
+                        ? { changedPaths: [...intent.changedPaths] }
+                        : {}),
+                },
+            };
+        case "plugin-enable":
+        case "plugin-disable":
+            return {
+                kind: intent.kind,
+                detail: { pluginId: intent.pluginId },
+            };
+        case "restart":
+            return { kind: "restart", detail: { reason: intent.reason } };
+    }
+}
+function formatError(err) {
+    return err instanceof Error ? (err.stack ?? err.message) : String(err);
+}
+/**
+ * Default env-pump wrapper. Lazy-imports the onboarding env-pump to keep the
+ * dependency graph clean (the operations module sits below the api module
+ * in the layering, but the env-pump genuinely owns the canonical mutation).
+ */
+async function defaultApplyProviderEnv(intent) {
+    const { applyOnboardingConnectionConfig, createProviderSwitchConnection } = await import("../../api/provider-switch-config.js");
+    const { loadElizaConfig, saveElizaConfig } = await import("../../config/config.js");
+    const connection = createProviderSwitchConnection({
+        provider: intent.provider,
+        ...(intent.apiKey ? { apiKey: intent.apiKey } : {}),
+        ...(intent.primaryModel ? { primaryModel: intent.primaryModel } : {}),
+    });
+    if (!connection) {
+        throw new Error(`[runtime-ops] hot reload: invalid provider "${intent.provider}"`);
+    }
+    const config = loadElizaConfig();
+    await applyOnboardingConnectionConfig(config, connection);
+    saveElizaConfig(config);
+}
+/**
+ * Default plugin notify. Iterates the runtime's plugins and calls
+ * `plugin.applyConfig` when defined. The hook receives the plugin's own
+ * config record (already attached to the plugin instance) and the runtime —
+ * matching the elizaOS Plugin contract.
+ *
+ * If no plugin defines `applyConfig`, this is a no-op log: env has been set
+ * and plugins will resolve the new values on their next call into the
+ * provider client.
+ */
+async function defaultNotifyConfigChanged(runtime, change) {
+    const plugins = runtime.plugins ?? [];
+    let notified = 0;
+    let failures = 0;
+    for (const plugin of plugins) {
+        if (typeof plugin.applyConfig !== "function")
+            continue;
+        try {
+            const pluginConfig = {};
+            if (plugin.config) {
+                for (const [key, value] of Object.entries(plugin.config)) {
+                    if (value === null || value === undefined)
+                        continue;
+                    pluginConfig[key] = String(value);
+                }
+            }
+            await plugin.applyConfig(pluginConfig, runtime);
+            notified += 1;
+        }
+        catch (err) {
+            failures += 1;
+            logger.warn(`[runtime-ops] hot reload: plugin "${plugin.name}" applyConfig failed: ${formatError(err)}`);
+        }
+    }
+    if (notified === 0 && failures === 0) {
+        logger.info(`[runtime-ops] no plugin reload hook found — env applied, plugins will pick up on next request (change=${change.kind})`);
+        return;
+    }
+    logger.info(`[runtime-ops] hot reload: notified ${notified} plugin(s), ${failures} failure(s) (change=${change.kind})`);
+}
+export function createHotStrategy(opts = {}) {
+    const applyProviderEnv = opts.applyProviderEnv ?? defaultApplyProviderEnv;
+    const notifyConfigChanged = opts.notifyConfigChanged ?? defaultNotifyConfigChanged;
+    return {
+        tier: "hot",
+        async apply(ctx) {
+            // ── Phase 1: apply-env ──────────────────────────────────────────────
+            const envStarted = nowMs();
+            if (ctx.intent.kind !== "provider-switch") {
+                // The hot strategy currently only handles provider-switch env mutations
+                // directly. Other hot-eligible intents (config-reload over env./vars./
+                // models.) flow through the plugin notify step only — env was already
+                // mutated by whoever scheduled the operation (e.g. the config writer).
+                await ctx.reportPhase(buildPhase("apply-env", "skipped", envStarted, nowMs(), {
+                    detail: { reason: `intent=${ctx.intent.kind}` },
+                }));
+            }
+            else {
+                try {
+                    await applyProviderEnv(ctx.intent);
+                    await ctx.reportPhase(buildPhase("apply-env", "succeeded", envStarted, nowMs(), {
+                        detail: { provider: ctx.intent.provider },
+                    }));
+                }
+                catch (err) {
+                    await ctx.reportPhase(buildPhase("apply-env", "failed", envStarted, nowMs(), {
+                        error: { message: formatError(err) },
+                    }));
+                    throw err;
+                }
+            }
+            // ── Phase 2: notify-plugins ─────────────────────────────────────────
+            const notifyStarted = nowMs();
+            const change = describeIntent(ctx.intent);
+            try {
+                await notifyConfigChanged(ctx.runtime, change);
+                await ctx.reportPhase(buildPhase("notify-plugins", "succeeded", notifyStarted, nowMs(), {
+                    detail: change.detail,
+                }));
+            }
+            catch (err) {
+                // Best-effort: env is already applied, so we surface this as a failed
+                // phase with a warning but do NOT throw — the operation should still
+                // succeed at the manager level.
+                logger.warn(`[runtime-ops] hot reload: notify-plugins failed (env already applied): ${formatError(err)}`);
+                await ctx.reportPhase(buildPhase("notify-plugins", "failed", notifyStarted, nowMs(), {
+                    error: { message: formatError(err) },
+                }));
+            }
+            return ctx.runtime;
+        },
+    };
+}

package/packages/agent/src/runtime/operations/repository.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Filesystem-backed RuntimeOperationRepository.
+ *
+ * Storage layout:
+ *   <stateDir>/runtime-operations/<id>.json   one JSON file per operation
+ *
+ * Atomic writes: write to <id>.json.tmp.<pid> then rename — same pattern
+ * the Eliza config uses (config.ts:saveElizaConfig).
+ *
+ * In-memory caches are populated lazily at first access from disk and kept
+ * in sync on every mutation. They make `findActive` and
+ * `findByIdempotencyKey` O(1) on the hot path.
+ *
+ * Hydration also reaps abandoned operations: anything still `pending` or
+ * `running` whose `startedAt` is older than 24h is force-marked `failed`
+ * with code `"abandoned"` (the process must have died mid-flight).
+ */
+import type { OperationPhase, RuntimeOperation, RuntimeOperationListOptions, RuntimeOperationRepository } from "./types.js";
+export declare class FilesystemRuntimeOperationRepository implements RuntimeOperationRepository {
+    private readonly dir;
+    private readonly byId;
+    private readonly byIdempotencyKey;
+    private activeId;
+    private hydrated;
+    constructor(stateDir?: string);
+    private hydrate;
+    private pathFor;
+    private persist;
+    private syncActiveSlot;
+    create(op: RuntimeOperation): Promise<void>;
+    update(id: string, patch: Partial<Omit<RuntimeOperation, "id" | "phases" | "intent" | "kind">>): Promise<void>;
+    appendPhase(id: string, phase: OperationPhase): Promise<void>;
+    updateLastPhase(id: string, patch: Partial<OperationPhase>): Promise<void>;
+    get(id: string): Promise<RuntimeOperation | null>;
+    list(opts?: RuntimeOperationListOptions): Promise<RuntimeOperation[]>;
+    findByIdempotencyKey(key: string): Promise<RuntimeOperation | null>;
+    findActive(): Promise<RuntimeOperation | null>;
+}
+/**
+ * Lazy per-process singleton. Constructed on first call so tests can swap
+ * the env or provide their own repository before the manager is built.
+ */
+export declare function getDefaultRepository(): FilesystemRuntimeOperationRepository;
+//# sourceMappingURL=repository.d.ts.map

package/packages/agent/src/runtime/operations/repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repository.d.ts","sourceRoot":"","sources":["../../../../../../src/runtime/operations/repository.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAMH,OAAO,KAAK,EACV,cAAc,EACd,gBAAgB,EAChB,2BAA2B,EAC3B,0BAA0B,EAC3B,MAAM,YAAY,CAAC;AAoCpB,qBAAa,oCACX,YAAW,0BAA0B;IAErC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAC7B,OAAO,CAAC,QAAQ,CAAC,IAAI,CAA4C;IACjE,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAkC;IACnE,OAAO,CAAC,QAAQ,CAAuB;IACvC,OAAO,CAAC,QAAQ,CAAS;gBAEb,QAAQ,GAAE,MAA0B;IAIhD,OAAO,CAAC,OAAO;IA8Cf,OAAO,CAAC,OAAO;IAIf,OAAO,CAAC,OAAO;IAIf,OAAO,CAAC,cAAc;IAWhB,MAAM,CAAC,EAAE,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;IAa3C,MAAM,CACV,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,OAAO,CAAC,IAAI,CAAC,gBAAgB,EAAE,IAAI,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAAC,CAAC,GAC1E,OAAO,CAAC,IAAI,CAAC;IAYV,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAc7D,eAAe,CACnB,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,OAAO,CAAC,cAAc,CAAC,GAC7B,OAAO,CAAC,IAAI,CAAC;IAwBV,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC;IAKjD,IAAI,CAAC,IAAI,CAAC,EAAE,2BAA2B,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC;IAerE,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC;IAYnE,UAAU,IAAI,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC;CAcrD;AAID;;;GAGG;AACH,wBAAgB,oBAAoB,IAAI,oCAAoC,CAK3E"}