martin-loop 0.1.5 → 1.3.0

package/dist/vendor/core/autonomy/autonomous-promotion.js

@@ -0,0 +1,346 @@
+import { createHash } from "node:crypto";
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { signFileAttestation } from "../attestation/sign.js";
+const AUTONOMOUS_PROMOTION_FILE = "autonomous-promotion.json";
+export function classifyAutonomySurface(path) {
+    const normalized = normalizePath(path);
+    const protectedRules = [
+        "packages/core/src/leash.ts",
+        "packages/core/src/policy.ts",
+        "packages/core/src/grounding.ts",
+        "packages/cli/src/index.ts"
+    ];
+    if (protectedRules.includes(normalized)) {
+        return {
+            path: normalized,
+            surface: "protected",
+            matchedRule: normalized
+        };
+    }
+    const protectedPrefixes = [
+        "packages/core/src/leash/",
+        "packages/core/src/policy/",
+        "packages/core/src/grounding/",
+        "packages/core/src/security/",
+        "packages/core/src/attestation/",
+        "packages/core/src/safety/",
+        "packages/core/src/sentinel/",
+        "packages/contracts/src/",
+        "packages/mcp/src/",
+        "docs/release/",
+        "docs/security/",
+        "docs/handoffs/",
+        ".planning/",
+        "scripts/"
+    ];
+    const matchedProtectedPrefix = protectedPrefixes.find((rule) => normalized.startsWith(rule));
+    if (matchedProtectedPrefix) {
+        return {
+            path: normalized,
+            surface: "protected",
+            matchedRule: `${matchedProtectedPrefix}**`
+        };
+    }
+    if (normalized === "martin.config.example.yaml") {
+        return {
+            path: normalized,
+            surface: "trusted_config",
+            matchedRule: "martin.config.example.yaml"
+        };
+    }
+    if (normalized.startsWith("packages/core/src/memory/")) {
+        return {
+            path: normalized,
+            surface: "trusted_code",
+            matchedRule: "packages/core/src/memory/**"
+        };
+    }
+    if (normalized.startsWith("packages/trace-intelligence/src/")) {
+        return {
+            path: normalized,
+            surface: "trusted_code",
+            matchedRule: "packages/trace-intelligence/src/**"
+        };
+    }
+    return {
+        path: normalized,
+        surface: "heuristic",
+        matchedRule: "default"
+    };
+}
+export function classifyAutonomySurfaceSet(paths) {
+    const surfaces = paths.map(classifyAutonomySurface);
+    if (surfaces.length === 0) {
+        return { surfaceClass: "heuristic", surfaces };
+    }
+    if (surfaces.some((surface) => surface.surface === "protected")) {
+        return { surfaceClass: "protected", surfaces };
+    }
+    if (surfaces.some((surface) => surface.surface === "heuristic")) {
+        return { surfaceClass: "heuristic", surfaces };
+    }
+    if (surfaces.some((surface) => surface.surface === "trusted_code")) {
+        return { surfaceClass: "trusted_code", surfaces };
+    }
+    return { surfaceClass: "trusted_config", surfaces };
+}
+export function evaluateAutonomyTripwires(input) {
+    const surfaceSet = classifyAutonomySurfaceSet(input.changedFiles);
+    const surfaces = surfaceSet.surfaces;
+    const reasonCodes = [];
+    if (surfaces.some((surface) => surface.surface === "protected")) {
+        reasonCodes.push("protected_surface");
+    }
+    if (!input.diffVerified) {
+        reasonCodes.push("unverifiable_diff");
+    }
+    if (!input.rollbackProofPresent) {
+        reasonCodes.push("missing_rollback_proof");
+    }
+    if (!input.attestationMatches) {
+        reasonCodes.push("attestation_mismatch");
+    }
+    if (input.repeatedGroundingCount >= 2) {
+        reasonCodes.push("repeated_grounding");
+    }
+    if (!input.verifierImproved) {
+        reasonCodes.push("verifier_no_improvement");
+    }
+    if (input.budgetPressure === "critical") {
+        reasonCodes.push("budget_pressure_escalation");
+    }
+    const uniqueReasonCodes = unique(reasonCodes);
+    const events = uniqueReasonCodes.map(buildTripwireEvent);
+    const failed = uniqueReasonCodes.length > 0;
+    return {
+        status: failed ? "fail_closed" : "pass",
+        decision: failed ? "human_escalation" : "continue",
+        sideEffectsAllowed: !failed,
+        reasonCodes: uniqueReasonCodes,
+        surfaces,
+        surfaceClass: surfaceSet.surfaceClass,
+        events
+    };
+}
+export function evaluateAutonomousPromotion(input) {
+    const tripwire = evaluateAutonomyTripwires(input);
+    if (tripwire.status === "fail_closed") {
+        if (shouldRouteFailClosedToRollbackOnly(tripwire.reasonCodes, input.rollbackReady)) {
+            return {
+                verdict: "rollback_only",
+                sideEffectsAllowed: true,
+                reasonCodes: [...tripwire.reasonCodes],
+                tripwire
+            };
+        }
+        return {
+            verdict: "human_escalation",
+            sideEffectsAllowed: false,
+            reasonCodes: [...tripwire.reasonCodes],
+            tripwire
+        };
+    }
+    if (tripwire.surfaceClass === "heuristic" && input.requestedMode === "promote") {
+        return {
+            verdict: "human_escalation",
+            sideEffectsAllowed: false,
+            reasonCodes: ["untrusted_surface"],
+            tripwire
+        };
+    }
+    if (input.requestedMode === "rollback") {
+        if (!input.rollbackReady) {
+            return {
+                verdict: "human_escalation",
+                sideEffectsAllowed: false,
+                reasonCodes: ["rollback_not_ready"],
+                tripwire
+            };
+        }
+        return {
+            verdict: "rollback_only",
+            sideEffectsAllowed: true,
+            reasonCodes: ["rollback_requested"],
+            tripwire
+        };
+    }
+    if (input.requestedMode === "shadow") {
+        return {
+            verdict: "shadow_only",
+            sideEffectsAllowed: false,
+            reasonCodes: ["shadow_requested"],
+            tripwire
+        };
+    }
+    if (!input.rollbackReady) {
+        return {
+            verdict: "human_escalation",
+            sideEffectsAllowed: false,
+            reasonCodes: ["rollback_not_ready"],
+            tripwire
+        };
+    }
+    if (!input.shadowEvidencePasses || input.holdoutEvidencePasses !== true) {
+        return {
+            verdict: "shadow_only",
+            sideEffectsAllowed: false,
+            reasonCodes: ["shadow_evidence_pending"],
+            tripwire
+        };
+    }
+    if (normalizeConfidence(input.confidenceScore) < confidenceThresholdForSurface(tripwire.surfaceClass)) {
+        return {
+            verdict: "shadow_only",
+            sideEffectsAllowed: false,
+            reasonCodes: ["shadow_evidence_pending"],
+            tripwire
+        };
+    }
+    return {
+        verdict: "promote",
+        sideEffectsAllowed: true,
+        reasonCodes: [],
+        tripwire
+    };
+}
+export function buildAutonomousPromotionArtifact(input) {
+    const decision = evaluateAutonomousPromotion(input);
+    const evidenceHash = sha256(canonicalStringify(input.evidence));
+    const confidenceScore = normalizeConfidence(input.confidenceScore);
+    const holdoutEvidencePasses = input.holdoutEvidencePasses ?? false;
+    const priorSuccessfulPromotions = input.priorSuccessfulPromotions ?? 0;
+    const unsignedArtifact = {
+        schemaVersion: "martin.autonomous-promotion.v1",
+        runId: input.runId,
+        attemptId: input.attemptId,
+        createdAt: input.createdAt,
+        requestedMode: input.requestedMode,
+        surfaceClass: decision.tripwire.surfaceClass,
+        confidenceScore,
+        shadowEvidencePasses: input.shadowEvidencePasses,
+        holdoutEvidencePasses,
+        rollbackReady: input.rollbackReady,
+        attestationVerified: input.attestationMatches,
+        priorSuccessfulPromotions,
+        diffHash: input.evidence.diffHash ?? null,
+        beforeArtifactHash: input.evidence.beforeArtifactHash ?? null,
+        afterArtifactHash: input.evidence.afterArtifactHash ?? null,
+        rollbackBoundaryRef: input.evidence.rollbackBoundaryRef ?? null,
+        improvementResultPath: input.evidence.improvementResultPath ?? null,
+        promotionPolicyVerdict: decision.verdict,
+        tripwireVerdict: decision.tripwire.status,
+        finalDisposition: decision.verdict,
+        verdict: decision.verdict,
+        sideEffectsAllowed: decision.sideEffectsAllowed,
+        reasonCodes: decision.reasonCodes,
+        changedFiles: input.changedFiles.map(normalizePath),
+        surfaces: decision.tripwire.surfaces,
+        evidence: input.evidence,
+        evidenceHash,
+        tripwire: decision.tripwire
+    };
+    const signature = {
+        algorithm: "sha256",
+        keyId: "deterministic-local-sha256",
+        signedAt: input.createdAt,
+        signature: `sha256:${sha256(canonicalStringify(unsignedArtifact))}`
+    };
+    return {
+        ...unsignedArtifact,
+        signature
+    };
+}
+export async function persistAutonomousPromotionArtifact(input) {
+    await mkdir(input.root, { recursive: true });
+    const path = join(input.root, AUTONOMOUS_PROMOTION_FILE);
+    await writeFile(path, `${canonicalPrettyStringify(input.artifact)}\n`, "utf8");
+    const attestationOptions = {
+        now: input.artifact.createdAt,
+        ...(input.martinHome ? { martinHome: input.martinHome } : {})
+    };
+    const attestation = await signFileAttestation(path, attestationOptions);
+    return {
+        fileName: AUTONOMOUS_PROMOTION_FILE,
+        path,
+        artifact: input.artifact,
+        attestation
+    };
+}
+function normalizePath(value) {
+    return value.replace(/\\/g, "/").replace(/^\.\//u, "");
+}
+function sha256(value) {
+    return createHash("sha256").update(value, "utf8").digest("hex");
+}
+function unique(values) {
+    return [...new Set(values)];
+}
+function normalizeConfidence(value) {
+    if (typeof value !== "number" || Number.isNaN(value)) {
+        return 1;
+    }
+    return Math.max(0, Math.min(1, value));
+}
+function confidenceThresholdForSurface(surface) {
+    switch (surface) {
+        case "trusted_config":
+            return 0.8;
+        case "trusted_code":
+            return 0.9;
+        case "heuristic":
+        case "protected":
+            return 1;
+        default:
+            return 1;
+    }
+}
+function buildTripwireEvent(reasonCode) {
+    const triggerReason = {
+        protected_surface: "candidate touched a permanently human-controlled surface",
+        untrusted_surface: "candidate requested autonomous promotion outside trusted surfaces",
+        unverifiable_diff: "canonical diff hash could not be verified",
+        missing_rollback_proof: "rollback proof or rollback boundary linkage is missing",
+        attestation_mismatch: "diff or artifact attestation did not match expected evidence",
+        repeated_grounding: "grounding failures repeated across the autonomy attempt",
+        verifier_no_improvement: "verifier reported no measurable improvement",
+        budget_pressure_escalation: "budget pressure reached the fail-closed escalation threshold"
+    };
+    return {
+        severity: "critical",
+        reasonCode,
+        triggerReason: triggerReason[reasonCode],
+        actionTaken: "block_and_escalate"
+    };
+}
+function shouldRouteFailClosedToRollbackOnly(reasonCodes, rollbackReady) {
+    if (!rollbackReady) {
+        return false;
+    }
+    const escalationOnly = new Set([
+        "protected_surface",
+        "untrusted_surface",
+        "missing_rollback_proof",
+        "attestation_mismatch",
+        "budget_pressure_escalation"
+    ]);
+    return reasonCodes.length > 0 && reasonCodes.every((reason) => !escalationOnly.has(reason));
+}
+function canonicalStringify(value) {
+    return JSON.stringify(sortCanonical(value));
+}
+function canonicalPrettyStringify(value) {
+    return JSON.stringify(sortCanonical(value), null, 2);
+}
+function sortCanonical(value) {
+    if (Array.isArray(value)) {
+        return value.map(sortCanonical);
+    }
+    if (!value || typeof value !== "object") {
+        return value;
+    }
+    return Object.fromEntries(Object.entries(value)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, nested]) => [key, sortCanonical(nested)]));
+}
+//# sourceMappingURL=autonomous-promotion.js.map

package/dist/vendor/core/autonomy/envelope-v2.d.ts

@@ -0,0 +1,29 @@
+import type { ApprovalPolicy, ExecutionProfile } from "../../contracts/index.js";
+export interface AutonomyEnvelopeV2Input {
+    taskId: string;
+    taskFamily: string;
+    requestedSurfaces: string[];
+    allowedSurfaces: string[];
+    verificationPlan: string[];
+    commands?: string[];
+    changedFiles?: string[];
+    allowedPaths?: string[];
+    deniedPaths?: string[];
+    executionProfile?: ExecutionProfile;
+    allowedNetworkDomains?: string[];
+    approvalPolicy?: ApprovalPolicy;
+    requiresHumanApproval?: boolean;
+}
+export interface AutonomyEnvelopeV2Decision {
+    taskId: string;
+    taskFamily: string;
+    decision: "admit" | "escalate";
+    envelopeStatus: "in_envelope" | "escalation_required" | "out_of_envelope";
+    sideEffectsAllowed: boolean;
+    zeroSideEffectsBeforeEscalation: boolean;
+    reasons: string[];
+    blockedSurfaces: Array<"command" | "filesystem" | "dependency">;
+    allowedClaimWording: string;
+    nonClaims: string[];
+}
+export declare function evaluateAutonomyEnvelopeV2(input: AutonomyEnvelopeV2Input): AutonomyEnvelopeV2Decision;

package/dist/vendor/core/autonomy/envelope-v2.js

@@ -0,0 +1,60 @@
+import { evaluateChangeApprovalLeash, evaluateFilesystemLeash, evaluateVerificationLeash } from "../leash.js";
+export function evaluateAutonomyEnvelopeV2(input) {
+    const reasons = [];
+    const allowedSurfaceSet = new Set(input.allowedSurfaces);
+    const blockedSurfaces = [];
+    const verificationCommands = [...input.verificationPlan, ...(input.commands ?? [])];
+    if (input.requestedSurfaces.some((surface) => !allowedSurfaceSet.has(surface))) {
+        reasons.push("requested surface outside autonomy envelope");
+    }
+    if (input.requiresHumanApproval) {
+        reasons.push("human approval required");
+    }
+    const commandDecision = evaluateVerificationLeash({
+        verificationPlan: verificationCommands,
+        ...(input.executionProfile ? { executionProfile: input.executionProfile } : {}),
+        ...(input.allowedNetworkDomains ? { allowedNetworkDomains: input.allowedNetworkDomains } : {})
+    });
+    if (commandDecision.blocked) {
+        reasons.push("verification command leash blocked one or more commands");
+        blockedSurfaces.push("command");
+    }
+    const filesystemDecision = evaluateFilesystemLeash({
+        changedFiles: input.changedFiles ?? [],
+        ...(input.allowedPaths ? { allowedPaths: input.allowedPaths } : {}),
+        ...(input.deniedPaths ? { deniedPaths: input.deniedPaths } : {})
+    });
+    if (filesystemDecision.blocked) {
+        reasons.push("filesystem leash blocked one or more changed files");
+        blockedSurfaces.push("filesystem");
+    }
+    const dependencyDecision = evaluateChangeApprovalLeash({
+        changedFiles: input.changedFiles ?? [],
+        ...(input.executionProfile ? { executionProfile: input.executionProfile } : {}),
+        approvalPolicy: input.approvalPolicy
+    });
+    if (dependencyDecision.blocked) {
+        reasons.push("dependency or config approval is required");
+        blockedSurfaces.push("dependency");
+    }
+    const uniqueBlockedSurfaces = [...new Set(blockedSurfaces)];
+    const envelopeStatus = reasons.length === 0
+        ? "in_envelope"
+        : input.requestedSurfaces.some((surface) => !allowedSurfaceSet.has(surface))
+            ? "out_of_envelope"
+            : "escalation_required";
+    const decision = reasons.length === 0 ? "admit" : "escalate";
+    return {
+        taskId: input.taskId,
+        taskFamily: input.taskFamily,
+        decision,
+        envelopeStatus,
+        sideEffectsAllowed: decision === "admit",
+        zeroSideEffectsBeforeEscalation: decision === "escalate",
+        reasons,
+        blockedSurfaces: uniqueBlockedSurfaces,
+        allowedClaimWording: "Autonomous inside operating envelope v2 with fail-closed escalation before file, network, or dependency side effects outside the envelope.",
+        nonClaims: ["unqualified autonomous", "no-boundary autonomy", "human-free operation on every task"]
+    };
+}
+//# sourceMappingURL=envelope-v2.js.map

package/dist/vendor/core/autonomy/envelope.d.ts

@@ -0,0 +1,17 @@
+export interface AutonomyEnvelopeInput {
+    taskId: string;
+    requestedSurfaces: string[];
+    allowedSurfaces: string[];
+    verificationPlan: string[];
+    commands: string[];
+    requiresHumanApproval: boolean;
+}
+export interface AutonomyEnvelopeDecision {
+    taskId: string;
+    decision: "admit" | "escalate";
+    sideEffectsAllowed: boolean;
+    reasons: string[];
+    allowedClaimWording: string;
+    nonClaims: string[];
+}
+export declare function evaluateAutonomyEnvelope(input: AutonomyEnvelopeInput): AutonomyEnvelopeDecision;

package/dist/vendor/core/autonomy/envelope.js

@@ -0,0 +1,27 @@
+import { evaluateVerificationLeash } from "../leash.js";
+export function evaluateAutonomyEnvelope(input) {
+    const reasons = [];
+    const allowedSurfaceSet = new Set(input.allowedSurfaces);
+    if (input.requestedSurfaces.some((surface) => !allowedSurfaceSet.has(surface))) {
+        reasons.push("requested surface outside autonomy envelope");
+    }
+    if (input.requiresHumanApproval) {
+        reasons.push("human approval required");
+    }
+    const leash = evaluateVerificationLeash({
+        verificationPlan: [...input.verificationPlan, ...input.commands]
+    });
+    if (!leash.allowed) {
+        reasons.push("verification command leash blocked one or more commands");
+    }
+    const decision = reasons.length === 0 ? "admit" : "escalate";
+    return {
+        taskId: input.taskId,
+        decision,
+        sideEffectsAllowed: decision === "admit",
+        reasons,
+        allowedClaimWording: "Autonomous inside the declared operating envelope only, with escalation before side effects for out-of-envelope work.",
+        nonClaims: ["unqualified autonomous", "no-boundary autonomy"]
+    };
+}
+//# sourceMappingURL=envelope.js.map

package/dist/vendor/core/autonomy/escalation-ledger.d.ts

@@ -0,0 +1,20 @@
+import { type AutonomyEnvelopeV2Decision, type AutonomyEnvelopeV2Input } from "./envelope-v2.js";
+export interface AutonomyEscalationLedgerEntry extends AutonomyEnvelopeV2Decision {
+}
+export interface AutonomyEscalationLedger {
+    ledgerId: "autonomy-envelope-v2";
+    generatedAt: string;
+    entries: AutonomyEscalationLedgerEntry[];
+    summary: {
+        totalTasks: number;
+        admittedTasks: number;
+        escalatedTasks: number;
+        zeroSideEffectEscalations: number;
+    };
+    allowedClaimWording: string;
+    nonClaims: string[];
+}
+export declare function buildAutonomyEscalationLedger(input: {
+    generatedAt?: string;
+    tasks: AutonomyEnvelopeV2Input[];
+}): AutonomyEscalationLedger;

package/dist/vendor/core/autonomy/escalation-ledger.js

@@ -0,0 +1,18 @@
+import { evaluateAutonomyEnvelopeV2 } from "./envelope-v2.js";
+export function buildAutonomyEscalationLedger(input) {
+    const entries = input.tasks.map((task) => evaluateAutonomyEnvelopeV2(task));
+    return {
+        ledgerId: "autonomy-envelope-v2",
+        generatedAt: input.generatedAt ?? new Date().toISOString(),
+        entries,
+        summary: {
+            totalTasks: entries.length,
+            admittedTasks: entries.filter((entry) => entry.decision === "admit").length,
+            escalatedTasks: entries.filter((entry) => entry.decision === "escalate").length,
+            zeroSideEffectEscalations: entries.filter((entry) => entry.zeroSideEffectsBeforeEscalation).length
+        },
+        allowedClaimWording: "Autonomous inside operating envelope v2 with fail-closed escalation before side effects outside the envelope.",
+        nonClaims: ["unqualified autonomous", "human-free operation on every task"]
+    };
+}
+//# sourceMappingURL=escalation-ledger.js.map

package/dist/vendor/core/autonomy/resume.d.ts

@@ -0,0 +1,15 @@
+export interface AutonomyResumeInput {
+    taskId: string;
+    checkpointState: "clean" | "workspace_modified" | "checkpoint_missing";
+    outOfEnvelope: boolean;
+    sideEffectsDetected: boolean;
+    force: boolean;
+}
+export interface AutonomyResumeDecision {
+    taskId: string;
+    decision: "resume" | "resume_with_force" | "escalate";
+    reasons: string[];
+    allowedClaimWording: string;
+    nonClaims: string[];
+}
+export declare function evaluateAutonomyResume(input: AutonomyResumeInput): AutonomyResumeDecision;

package/dist/vendor/core/autonomy/resume.js

@@ -0,0 +1,23 @@
+export function evaluateAutonomyResume(input) {
+    const reasons = [];
+    if (input.checkpointState === "workspace_modified" && !input.force) {
+        reasons.push("workspace modified since checkpoint");
+    }
+    if (input.checkpointState === "checkpoint_missing") {
+        reasons.push("checkpoint missing");
+    }
+    if (input.outOfEnvelope) {
+        reasons.push("task moved outside the autonomy envelope");
+    }
+    if (input.sideEffectsDetected) {
+        reasons.push("side effects detected before safe resume");
+    }
+    return {
+        taskId: input.taskId,
+        decision: reasons.length === 0 ? (input.force && input.checkpointState === "workspace_modified" ? "resume_with_force" : "resume") : "escalate",
+        reasons,
+        allowedClaimWording: "Pause and resume are bounded by checkpoint integrity and envelope checks before a run continues autonomously.",
+        nonClaims: ["unbounded autonomous recovery", "resume without integrity checks"]
+    };
+}
+//# sourceMappingURL=resume.js.map

package/dist/vendor/core/circuit/circuit-breaker.d.ts

@@ -0,0 +1,60 @@
+export type CircuitState = "CLOSED" | "OPEN" | "HALF_OPEN";
+export interface CircuitBreakerConfig {
+    /** Number of consecutive failures before opening the circuit. Default: 3 */
+    failureThreshold: number;
+    /** Time in OPEN state before transitioning to HALF_OPEN (ms). Default: 60000 */
+    cooldownMs: number;
+    /** Sliding window for failure counting (ms). Default: 300000 (5 minutes) */
+    windowMs: number;
+}
+export interface CircuitBreakerState {
+    state: CircuitState;
+    failureCount: number;
+    lastFailureTime?: string;
+    openedAt?: string;
+    adapterId: string;
+}
+export declare class CircuitBreaker {
+    private readonly config;
+    private readonly adapterId;
+    private state;
+    private failureCount;
+    private lastFailureTime?;
+    private openedAt?;
+    constructor(adapterId: string, config?: Partial<CircuitBreakerConfig>);
+    /**
+     * Returns the current circuit breaker state snapshot.
+     */
+    getState(): CircuitBreakerState;
+    /**
+     * Returns true if a call should be allowed through.
+     * - CLOSED: always allowed
+     * - HALF_OPEN: one probe call allowed
+     * - OPEN: blocked unless cooldown has elapsed (transitions to HALF_OPEN)
+     */
+    canCall(now?: Date): boolean;
+    /**
+     * Record a successful adapter call.
+     * HALF_OPEN → CLOSED on success.
+     */
+    recordSuccess(): void;
+    /**
+     * Record a failed adapter call.
+     * CLOSED: increments failure count; if threshold reached, opens circuit.
+     * HALF_OPEN: re-opens circuit (probe failed).
+     */
+    recordFailure(now?: Date): void;
+    /**
+     * Manually reset the circuit breaker to CLOSED state.
+     */
+    reset(): void;
+}
+/**
+ * Serializes a CircuitBreaker instance to a JSON string.
+ */
+export declare function serializeState(breaker: CircuitBreaker): string;
+/**
+ * Deserializes a JSON string back into a CircuitBreaker instance.
+ * Restores internal state including failure count, timestamps, and state.
+ */
+export declare function deserializeState(json: string, configOverride?: Partial<CircuitBreakerConfig>): CircuitBreaker;