@tangle-network/agent-knowledge 4.1.0 → 5.0.1

package/dist/memory/index.d.ts

@@ -1,706 +1,8 @@
-import { b as AgentMemoryAdapter, j as AgentMemorySearchOptions, d as AgentMemoryContext, f as AgentMemoryHit, i as AgentMemoryScope, k as AgentMemoryWriteInput, l as AgentMemoryWriteResult, u as KnowledgeBenchmarkFamily, D as KnowledgeBenchmarkSplit, H as KnowledgeMemoryBenchmarkTaskKind, J as KnowledgeMemoryFactMatcher, h as AgentMemoryRunLease, I as KnowledgeMemoryEvent, G as KnowledgeMemoryBenchmarkCase, e as AgentMemoryControllerMode, A as AgentMemoryAcquireRunLease, $ as RetrievalHoldoutConfig, _ as RetrievalHoldoutCallContext, a2 as RetrievalHoldoutResult, Z as RetrievalHoldoutBypassReason, a1 as RetrievalHoldoutEvent } from '../types-DP38encz.js';
-export { c as AgentMemoryBranchIsolation, g as AgentMemoryKind, Q as OwnedAgentMemoryRunLease, a0 as RetrievalHoldoutEligibleItem, a3 as RetrievalHoldoutSessionState, af as acquireAgentMemoryRunLease } from '../types-DP38encz.js';
-import { CampaignResult, Scenario, DispatchContext, CampaignStorage, CostLedgerHandle, JudgeConfig, HeldoutSignificance, Lineage, GovernorContext, GovernorOp, SurfaceProposer, LineageStore, HeldoutSignificanceOptions } from '@tangle-network/agent-eval/campaign';
-import { OffPolicyTrajectory } from '@tangle-network/agent-eval/rl';
-import { z } from 'zod';
-import { S as SourceRecord } from '../types-6x0OpfW6.js';
-
-declare function defaultGetMemoryContext(adapter: Pick<AgentMemoryAdapter, 'search'>, query: string, options?: AgentMemorySearchOptions): Promise<AgentMemoryContext>;
-declare function renderMemoryContext(hits: AgentMemoryHit[]): string;
-
-type AgentMemoryVisibility = 'private' | 'team' | 'shared';
-type AgentMemoryBranchLifetime = 'resumable' | 'attempt';
-interface AgentMemorySharingPolicy {
-    read: readonly AgentMemoryVisibility[];
-    write: AgentMemoryVisibility;
-}
-interface AgentMemoryJournalEntry {
-    sequence: number;
-    input: AgentMemoryWriteInput;
-    result: AgentMemoryWriteResult;
-}
-interface AgentMemoryBranchSnapshot {
-    branchId: string;
-    lifetime: AgentMemoryBranchLifetime;
-    parentBranchId?: string;
-    adapterId: string;
-    policy: AgentMemorySharingPolicy;
-    baseScope: AgentMemoryScope;
-    journal: readonly AgentMemoryJournalEntry[];
-    digest: `sha256:${string}`;
-}
-interface AgentMemoryBranch extends AgentMemoryAdapter {
-    readonly branchId: string;
-    readonly lifetime: AgentMemoryBranchLifetime;
-    readonly parentBranchId?: string;
-    readonly policy: AgentMemorySharingPolicy;
-    snapshot(): Promise<AgentMemoryBranchSnapshot>;
-    fork(options: {
-        branchId: string;
-        adapter?: AgentMemoryAdapter;
-        policy?: AgentMemorySharingPolicy;
-        baseScope?: AgentMemoryScope;
-        lifetime?: AgentMemoryBranchLifetime;
-    }): Promise<AgentMemoryBranch>;
-}
-interface CreateAgentMemoryBranchOptions {
-    adapter: AgentMemoryAdapter;
-    branchId: string;
-    parentBranchId?: string;
-    policy?: AgentMemorySharingPolicy;
-    baseScope?: AgentMemoryScope;
-    /** Attempt branches use a new ID after a process restart and cannot bind persisted state. */
-    lifetime?: AgentMemoryBranchLifetime;
-    /** Rebind a persisted branch whose external memory is still present. */
-    snapshot?: AgentMemoryBranchSnapshot;
-    /** Optional exact logical scopes allowed to write, used by crash-safe experiments. */
-    allowedWriteScopes?: readonly AgentMemoryScope[];
-}
-interface ForkAgentMemoryBranchSnapshotOptions {
-    snapshot: AgentMemoryBranchSnapshot;
-    adapter: AgentMemoryAdapter;
-    branchId: string;
-    policy?: AgentMemorySharingPolicy;
-    baseScope?: AgentMemoryScope;
-    lifetime?: AgentMemoryBranchLifetime;
-}
-/**
- * Isolates one candidate branch and records accepted writes for durable resume
- * or replay into a child branch, including a child backed by another provider.
- */
-declare function createAgentMemoryBranch(options: CreateAgentMemoryBranchOptions): AgentMemoryBranch;
-/** Replays a durable journal into a fresh provider branch. */
-declare function forkAgentMemoryBranchSnapshot(options: ForkAgentMemoryBranchSnapshotOptions): Promise<AgentMemoryBranch>;
-
-interface AgentMemorySequenceProbe {
-    id: string;
-    query: string;
-    scope?: AgentMemoryScope;
-    limit?: number;
-    taskKind?: KnowledgeMemoryBenchmarkTaskKind;
-    requiredFacts?: readonly KnowledgeMemoryFactMatcher[];
-    forbiddenFacts?: readonly KnowledgeMemoryFactMatcher[];
-    expectedEventIds?: readonly string[];
-    expectedActorIds?: readonly string[];
-    referenceAnswer?: string;
-}
-interface AgentMemorySequenceStep {
-    id: string;
-    instruction?: string;
-    scope?: AgentMemoryScope;
-    writes?: readonly AgentMemoryWriteInput[];
-    parallelWrites?: boolean;
-    probes?: readonly AgentMemorySequenceProbe[];
-    parallelProbes?: boolean;
-    metadata?: Record<string, unknown>;
-}
-interface AgentMemorySequence {
-    id: string;
-    family: KnowledgeBenchmarkFamily | string;
-    split?: KnowledgeBenchmarkSplit;
-    steps: readonly AgentMemorySequenceStep[];
-    /** Exact scopes a runtime callback may write beyond scopes declared by steps. */
-    cleanupScopes?: readonly AgentMemoryScope[];
-    tags?: readonly string[];
-    metadata?: Record<string, unknown>;
-}
-interface BuildAgentMemorySequencesFromBenchmarkCasesOptions {
-    memoryAgentId?: string;
-    eventScope?: (input: {
-        event: KnowledgeMemoryEvent;
-        case: KnowledgeMemoryBenchmarkCase;
-        eventIndex: number;
-    }) => AgentMemoryScope;
-    probeScope?: (testCase: KnowledgeMemoryBenchmarkCase) => AgentMemoryScope;
-}
-interface AgentMemoryExperimentCandidate {
-    id: string;
-    label?: string;
-    /** Change when provider configuration changes so cached cells cannot be reused. */
-    ref: string;
-    /** Local construction is free; call markExternalCall before billable provisioning or reconnects. */
-    createAdapter(input: {
-        branchId: string;
-        sequence: AgentMemorySequence;
-        rep: number;
-        seed: number;
-        purpose: 'execute' | 'recovery';
-        signal: AbortSignal;
-        markExternalCall(): void;
-    }): AgentMemoryAdapter | null | Promise<AgentMemoryAdapter | null>;
-    policy?: AgentMemorySharingPolicy;
-    baseScope?: AgentMemoryScope;
-    /** Conservative external provider charge for one complete history. */
-    externalCostUsdPerSequence?: number;
-    /** Conservative extra provider charge when recovering one interrupted history. */
-    externalRecoveryCostUsdPerAttempt?: number;
-    /** Release resources and, when cleanupBranches is false, delete the isolated state. */
-    disposeAdapter?(adapter: AgentMemoryAdapter): Promise<void>;
-}
-interface AgentMemorySequenceProbeResult {
-    id: string;
-    stepId: string;
-    query: string;
-    score: number;
-    passed: boolean;
-    dimensions: Record<string, number>;
-    applicableDimensions: readonly string[];
-    notes: string;
-    hitIds: readonly string[];
-}
-interface AgentMemorySequenceArtifact {
-    candidateId: string;
-    sequenceId: string;
-    score: number;
-    passed: boolean;
-    dimensions: Record<string, number>;
-    dimensionSampleCounts: Record<string, number>;
-    probes: readonly AgentMemorySequenceProbeResult[];
-    branchDigest: string;
-    journalEntries: number;
-    durationMs: number;
-}
-interface AgentMemorySequenceScenario extends Scenario {
-    kind: 'agent-memory-sequence';
-    candidateId: string;
-    sequenceId: string;
-    sequence: AgentMemorySequence;
-    seedGroup: string;
-}
-interface AgentMemoryExperimentRankingRow {
-    rank: number;
-    candidateId: string;
-    label: string;
-    scoreMean: number;
-    passRate: number;
-    totalSequences: number;
-    totalCells: number;
-    totalProbes: number;
-    cellsFailed: number;
-    totalCostUsd: number;
-    durationMs: number;
-    dimensions: Record<string, number>;
-}
-interface RunAgentMemoryExperimentOptions {
-    experimentId: string;
-    /** Stable external branch namespace; distributed workers must use the same value. */
-    experimentRunId?: string;
-    sequences: readonly AgentMemorySequence[];
-    candidates: readonly AgentMemoryExperimentCandidate[];
-    /** Retired candidates retained only so interrupted branches can be cleaned on resume. */
-    recoveryCandidates?: readonly AgentMemoryExperimentCandidate[];
-    runDir: string;
-    executeStep?: (input: {
-        memory: AgentMemoryBranch;
-        candidateId: string;
-        sequence: AgentMemorySequence;
-        step: AgentMemorySequenceStep;
-        context: DispatchContext;
-    }) => Promise<void>;
-    /** Required with executeStep; identify the runtime/profile behavior in cache keys. */
-    executeStepRef?: string;
-    onBranchSnapshot?: (input: {
-        candidateId: string;
-        sequenceId: string;
-        cellId: string;
-        snapshot: AgentMemoryBranchSnapshot;
-    }) => Promise<void> | void;
-    cleanupBranches?: boolean;
-    storage?: CampaignStorage;
-    repo?: string;
-    seed?: number;
-    reps?: number;
-    resumable?: boolean;
-    costCeiling?: number;
-    /** Shared across nested experiments when an outer improvement run owns spend. */
-    costLedger?: CostLedgerHandle;
-    costPhase?: string;
-    maxConcurrency?: number;
-    dispatchTimeoutMs?: number;
-    /** Total deadline for each provider cleanup, close, or recovery operation. */
-    cleanupTimeoutMs?: number;
-    /** Refuse a damaged run with more unfinished attempts than this. Default 1000. */
-    maxRecoveryAttempts?: number;
-    /** Bound repeated provider cleanup after process crashes. Default 3 per attempt. */
-    maxRecoveryRetriesPerAttempt?: number;
-    now?: () => Date;
-    /** Required with custom storage when all controllers are confined to one process. */
-    controllerMode?: AgentMemoryControllerMode;
-    /** Required for distributed controllers that share custom storage. */
-    acquireRunLease?: AgentMemoryAcquireRunLease;
-}
-type AgentMemoryExperimentRunLease = AgentMemoryRunLease;
-interface AgentMemoryAttemptEvent {
-    schema: 2;
-    status: 'started' | 'cleaned';
-    branchId: string;
-    candidateId: string;
-    candidateRef: string;
-    sequenceId: string;
-    rep: number;
-    seed: number;
-    cleanupBranches: boolean;
-    externalCostUsdPerSequence: number;
-    externalRecoveryCostUsdPerAttempt: number;
-    recordedAt: string;
-    recovery: boolean;
-}
-interface RunAgentMemoryExperimentResult {
-    campaign: CampaignResult<AgentMemorySequenceArtifact, AgentMemorySequenceScenario>;
-    rows: readonly AgentMemoryExperimentRankingRow[];
-    totalCostUsd: number;
-    /** Recovery spend for retired candidates, excluded from ranking rows but included in totalCostUsd. */
-    unrankedRecoveryCostUsd: number;
-    leaderCandidateId?: string;
-    rankingJsonPath: string;
-    rankingMarkdownPath: string;
-    attemptLogPath: string;
-    recoveryLogPath: string;
-}
-
-/** Converts existing ordered memory benchmark cases into executable histories. */
-
-declare function buildAgentMemorySequencesFromBenchmarkCases(cases: readonly KnowledgeMemoryBenchmarkCase[], options?: BuildAgentMemorySequencesFromBenchmarkCasesOptions): AgentMemorySequence[];
-declare function buildAgentMemorySequenceScenarios(sequences: readonly AgentMemorySequence[], candidates: readonly Pick<AgentMemoryExperimentCandidate, 'id'>[]): AgentMemorySequenceScenario[];
-declare function agentMemorySequenceJudge(): JudgeConfig<AgentMemorySequenceArtifact, AgentMemorySequenceScenario>;
-
-/** Runs ordered, branch-isolated memory histories across candidate systems. */
-declare function runAgentMemoryExperiment(options: RunAgentMemoryExperimentOptions): Promise<RunAgentMemoryExperimentResult>;
-
-interface GraphitiMcpClientLike {
-    callTool(request: {
-        name: string;
-        arguments?: Record<string, unknown>;
-    }): Promise<unknown>;
-}
-interface GraphitiMemoryAdapterOptions {
-    client: GraphitiMcpClientLike;
-    id?: string;
-    /** Stable server/deployment identity for cache-key helpers. Never put credentials here. */
-    backendRef?: string;
-    defaultScope?: AgentMemoryScope;
-    consistency?: 'queued' | 'visible';
-    ingestionTimeoutMs?: number;
-    pollIntervalMs?: number;
-    /** Maximum episodes inspected to prove a queued write became visible. */
-    episodeScanLimit?: number;
-    provenanceEpisodeLimit?: number;
-    search?: readonly ('facts' | 'nodes')[];
-    toolNames?: Partial<GraphitiToolNames>;
-}
-interface GraphitiToolNames {
-    addMemory: string;
-    searchFacts: string;
-    searchNodes: string;
-    getEpisodes: string;
-    clearGraph: string;
-}
-/** Connects the official Graphiti MCP server without coupling to its Python internals. */
-declare function createGraphitiMemoryAdapter(options: GraphitiMemoryAdapterOptions): AgentMemoryAdapter;
-declare function graphitiMemoryAdapterIdentity(options: Pick<GraphitiMemoryAdapterOptions, 'id' | 'consistency' | 'ingestionTimeoutMs' | 'pollIntervalMs' | 'episodeScanLimit' | 'provenanceEpisodeLimit' | 'search' | 'toolNames' | 'defaultScope'> & {
-    backendRef: string;
-}): string;
-
-/**
- * Deterministic uniform [0,1) for assignment draws. The sha256 key derivation is ours — it makes
- * every draw replayable from the logged keys alone (design rule D5) — while the generator core is
- * the substrate's `mulberry32` (@tangle-network/agent-eval statistics vocabulary), seeded with the
- * top 32 bits of the digest, so the statistical machinery is reused rather than forked.
- */
-declare function deterministicRng(key: string): number;
-/**
- * Value-hash of the knobs that DEFINE the experiment (epsilon + watchlist, order-independent).
- * Everything else on the config (callbacks, attribution stamps, privacy flags) does not change
- * which assignments are drawn, so it stays out of the hash.
- */
-declare function retrievalHoldoutConfigHash(config: Pick<RetrievalHoldoutConfig, 'epsilon' | 'watchlist'>): string;
-/**
- * Pure per-call holdout: takes post-filter hits, returns delivered hits plus the log event
- * and the next session state. Suppression only removes items (no backfill), and it happens
- * before rendering so a drop session's context is byte-identical to a natural smaller retrieval.
- */
-declare function applyRetrievalHoldout(hits: AgentMemoryHit[], config: RetrievalHoldoutConfig, ctx?: RetrievalHoldoutCallContext): RetrievalHoldoutResult;
-/**
- * Logs a holdout event for adapter context paths that answer WITHOUT going through the
- * search→render seam (Neo4j short-term conversation context, raw-string getContext results),
- * so a consumer with a holdout configured still sees every call and the fraction-under-experiment
- * denominator stays honest instead of silently losing these calls. No suppression is applied:
- * dropping is only meaningful for retrieved memory hits, never for conversation context.
- */
-declare function emitRetrievalHoldoutBypass(hits: AgentMemoryHit[], config: RetrievalHoldoutConfig, ctx: Omit<RetrievalHoldoutCallContext, 'session'>, bypassReason: RetrievalHoldoutBypassReason): RetrievalHoldoutEvent;
-/**
- * Clears all sticky-session state. For test isolation and experiment-epoch boundaries;
- * sessions in flight afterwards re-draw deterministically (same rng keys), so with the default
- * rng a reset is invisible in the logs unless eligibility sets changed in between.
- */
-declare function resetRetrievalHoldoutRegistry(): void;
-/**
- * Convenience wrapper that threads session state internally, keyed by the VALUE of the
- * experiment-defining knobs (configHash = epsilon + sorted watchlist) plus sessionId, so a fresh
- * config object per call — the natural pattern when options are built inline — keeps full
- * stickiness. Distinct experiments never share session state; two config objects with the same
- * epsilon/watchlist are the same experiment by definition.
- */
-declare function applySessionStickyRetrievalHoldout(hits: AgentMemoryHit[], config: RetrievalHoldoutConfig, ctx?: Omit<RetrievalHoldoutCallContext, 'session'>): RetrievalHoldoutResult;
-/** Aggregated view of one session's holdout exposure — the randomization unit of this design. */
-interface RetrievalHoldoutSessionSummary {
-    /** `${configHash}:${sessionIdHash}` — the trajectory's runId. */
-    runId: string;
-    configHash: string;
-    sessionIdHash: string;
-    sessionHoldout: boolean;
-    sessionTargetId: string | null;
-    /** Item actually suppressed in this session (equals sessionTargetId when a drop occurred). */
-    droppedId: string | null;
-    /** |watchlist ∩ E| at the session's first intersecting randomized call; 0 when never intersecting. */
-    firstCandidateCount: number;
-    /** Randomized retrieval calls observed for this session. */
-    callCount: number;
-    /** Adapter bypass calls observed for this session (logged, never randomized). */
-    bypassCallCount: number;
-    /** Session-level probability of the OBSERVED assignment under the behavior policy. */
-    behaviorProb: number;
-    /** True when the session's events disagree on arm or target (e.g. registry eviction re-draw). */
-    mixedExposure: boolean;
-    /** Present only on sessions surfaced in `excluded` rather than converted. */
-    exclusionReason?: 'mixed-exposure' | 'no-randomized-calls';
-}
-interface RetrievalHoldoutOffPolicyOptions {
-    /**
-     * Realized outcome PER SESSION, keyed by sessionIdHash — the session is the randomization
-     * unit, so rewards are per session, never per call. A missing entry for an included session
-     * throws: silently dropping unscored sessions would corrupt the estimator's denominator, so
-     * filter events to scored sessions upstream instead.
-     */
-    rewards: Record<string, number>;
-    /**
-     * Target-policy probability of the session's observed assignment. Default models the
-     * always-deliver-in-full policy: 1 for full-delivery sessions, 0 for drop sessions.
-     */
-    targetProb?: (session: RetrievalHoldoutSessionSummary) => number;
-    /** Per-session reward-model prediction enabling `doublyRobust`; when absent, qHat is null. */
-    qHat?: (session: RetrievalHoldoutSessionSummary) => number | null;
-}
-interface RetrievalHoldoutOffPolicyResult {
-    /** One trajectory per (configHash, sessionIdHash), never per call. */
-    trajectories: OffPolicyTrajectory[];
-    /** 1:1 with `trajectories` (same order): the diagnostic view of each converted session. */
-    sessions: RetrievalHoldoutSessionSummary[];
-    /** Sessions not converted because exposure was mixed or retrieval was bypassed. */
-    excluded: RetrievalHoldoutSessionSummary[];
-    /** Events with no sessionIdHash: outside session randomization, cannot join a reward. */
-    unattributableEvents: number;
-}
-/**
- * Maps retrieval-dropout events onto one `OffPolicyTrajectory` per session for use with
- * `inverseProbabilityWeighting`, `selfNormalizedImportanceWeighting`, or `doublyRobust`.
- * Randomization occurs once per session: the arm is selected with P(dropout) = epsilon and
- * the sticky target is drawn once,
- * uniformly over watchlist ∩ E at the session's first intersecting call.
- *
- * Session-level action space and behavior probabilities (they sum to 1 by construction):
- * - full delivery: `1 - epsilon`;
- * - drop candidate i of k = |watchlist ∩ E_first|: `epsilon / k` each (the draw event's logged
- *   `dropPropensity`);
- * - sessions whose eligibility sets never intersect the watchlist: probability 1, because full
- *   delivery was certain in either arm.
- *
- * Per-call events are repeated observations WITHIN one session-level randomization; per-call
- * IPW is statistically invalid for this design (per-call "propensities" imply an action
- * distribution summing to more than 1 and bias IPS downward). Calls where the sticky target is
- * absent from E, and adapter bypass calls, fold into the session summary (callCount /
- * bypassCallCount) instead of generating independent propensities.
- *
- * Join contract: `rewards` is keyed by `sessionIdHash` (sha256(sessionId) first 16 hex; compute
- * the same prefix over the outcome table's session ids, or log with
- * `includePlaintextIdentifiers: true` and join on raw ids upstream). Events are grouped per
- * (configHash, sessionIdHash) so different experiment configs are never pooled. Mixed-exposure
- * sessions (arm or target disagreement, e.g. after registry eviction) are excluded from the
- * trajectories and surfaced in `excluded` for analysis.
- */
-declare function toOffPolicyTrajectory(events: RetrievalHoldoutEvent[], options: RetrievalHoldoutOffPolicyOptions): RetrievalHoldoutOffPolicyResult;
-
-interface AgentMemoryImprovementSeed<TConfig> {
-    config: TConfig;
-    track: string;
-    vision?: string;
-    proposer: string;
-}
-interface AgentMemoryDimensionComparison {
-    dimension: string;
-    n: number;
-    expectedN: number;
-    measured: boolean;
-    meanDelta: number;
-    low: number;
-    high: number;
-    tolerance: number;
-    regressed: boolean;
-}
-interface AgentMemoryPromotionDecision {
-    status: 'promote' | 'hold' | 'no-change';
-    reasons: readonly string[];
-    baselineScore: number;
-    winnerScore: number;
-    lift: number;
-    significance?: HeldoutSignificance;
-    criticalDimensions: readonly AgentMemoryDimensionComparison[];
-}
-interface AgentMemoryActivation {
-    id: string;
-    status: 'not-eligible' | 'not-configured' | 'pending' | 'activated' | 'recovered' | 'already-activated';
-    journalPath: string;
-}
-interface AgentMemoryActivationDriver<TConfig> {
-    /** Change whenever activation behavior or the external target changes. */
-    ref: string;
-    /** Return the exact currently active configuration. */
-    readCurrent(): Promise<TConfig>;
-    /** Atomically replace expectedConfig with config, or fail on a concurrent change. */
-    compareAndSet(input: {
-        activationId: string;
-        expectedConfig: TConfig;
-        expectedSurfaceHash: string;
-        config: TConfig;
-        surfaceHash: string;
-        decision: AgentMemoryPromotionDecision;
-        lineage: Lineage;
-        holdout: RunAgentMemoryExperimentResult;
-    }): Promise<void>;
-}
-type AgentMemoryImprovementRunLease = AgentMemoryRunLease;
-interface AgentMemoryGovernor {
-    decide(context: GovernorContext & {
-        costLedger: CostLedgerHandle;
-        costPhase: string;
-    }): GovernorOp | Promise<GovernorOp>;
-}
-interface RunAgentMemoryImprovementOptions<TConfig> {
-    experimentId: string;
-    trainSequences: readonly AgentMemorySequence[];
-    holdoutSequences: readonly AgentMemorySequence[];
-    /** First entry is the current baseline; remaining entries seed independent search tracks. */
-    seeds: readonly AgentMemoryImprovementSeed<TConfig>[];
-    createCandidate(input: {
-        config: TConfig;
-        candidateId: string;
-        surfaceHash: string;
-    }): Omit<AgentMemoryExperimentCandidate, 'id'> | Promise<Omit<AgentMemoryExperimentCandidate, 'id'>>;
-    proposer: SurfaceProposer;
-    /** Optional proposer implementations keyed by seed and branch proposer labels. */
-    proposers?: Readonly<Record<string, SurfaceProposer>>;
-    /** Stable version or commit for the candidate factory, proposer, and governor. */
-    improvementRef: string;
-    governor?: AgentMemoryGovernor;
-    budget: {
-        maxSteps: number;
-    };
-    populationSize?: number;
-    candidateConcurrency?: number;
-    sequenceConcurrency?: number;
-    runDir: string;
-    repo?: string;
-    storage?: CampaignStorage;
-    lineageStore?: LineageStore;
-    /** Required with custom storage when all controllers are confined to one process. */
-    controllerMode?: AgentMemoryControllerMode;
-    /** Required for distributed controllers using custom storage. Worker concurrency is independent. */
-    acquireRunLease?: AgentMemoryAcquireRunLease;
-    seed?: number;
-    reps?: number;
-    resumable?: boolean;
-    dispatchTimeoutMs?: number;
-    cleanupTimeoutMs?: number;
-    maxRecoveryAttempts?: number;
-    maxRecoveryRetriesPerAttempt?: number;
-    maxTotalCostUsd?: number;
-    executeStep?: RunAgentMemoryExperimentOptions['executeStep'];
-    executeStepRef?: string;
-    onBranchSnapshot?: RunAgentMemoryExperimentOptions['onBranchSnapshot'];
-    cleanupBranches?: boolean;
-    serializeConfig?: (config: TConfig) => string;
-    parseConfig?: (surface: string) => TConfig;
-    significance?: HeldoutSignificanceOptions;
-    criticalDimensions?: readonly string[];
-    criticalDimensionTolerance?: number;
-    minHoldoutScore?: number;
-    activation?: AgentMemoryActivationDriver<TConfig>;
-    activationTimeoutMs?: number;
-    now?: () => Date;
-}
-interface RunAgentMemoryImprovementResult<TConfig> {
-    lineage: Lineage;
-    baselineConfig: TConfig;
-    winnerConfig: TConfig;
-    baselineSurface: string;
-    winnerSurface: string;
-    baselineSurfaceHash: string;
-    winnerSurfaceHash: string;
-    decision: AgentMemoryPromotionDecision;
-    activation: AgentMemoryActivation;
-    holdout?: RunAgentMemoryExperimentResult;
-    totalCostUsd: number;
-    resultJsonPath: string;
-}
-
-/** Searches branchable memory configurations and activates only a fresh holdout win. */
-declare function runAgentMemoryImprovement<TConfig>(options: RunAgentMemoryImprovementOptions<TConfig>): Promise<RunAgentMemoryImprovementResult<TConfig>>;
-
-declare const DEFAULT_MEMORY_CLEANUP_TIMEOUT_MS = 180000;
-declare class AgentMemoryLifecycleTimeoutError extends Error {
-    readonly operation: string;
-    readonly timeoutMs: number;
-    constructor(operation: string, timeoutMs: number);
-}
-declare class AgentMemoryLifecycleUnsafeError extends Error {
-    readonly operation: string;
-    readonly priorTimeout: AgentMemoryLifecycleTimeoutError;
-    constructor(operation: string, priorTimeout: AgentMemoryLifecycleTimeoutError);
-}
-declare function resolveMemoryCleanupTimeoutMs(value: number | undefined, label: string): number;
-declare function runBoundedMemoryLifecycle<T>(input: {
-    operation: string;
-    timeoutMs: number;
-    /** Prevent later operations from using the same client while timed-out work may still be running. */
-    resource?: object;
-    /** Cooperatively cancel provider work before reporting a timeout. */
-    abortController?: AbortController;
-    run(): Promise<T> | T;
-}): Promise<T>;
-declare function memoryRecoveryDelayMs(adapter: AgentMemoryAdapter): number;
-declare function sleepForMemoryRecovery(delayMs: number, assertOwned: () => Promise<void>, timeoutMs?: number, operation?: string): Promise<void>;
-declare function createMemoryExecutionPool(limit: number): {
-    run<T>(operation: () => Promise<T>): Promise<T>;
-};
-
-type Mem0ClientMode = 'hosted' | 'oss';
-interface Mem0ClientLike {
-    add(messages: Array<{
-        role: string;
-        content: string;
-    }>, options?: Record<string, unknown>): Promise<unknown>;
-    search(query: string, options?: Record<string, unknown>): Promise<unknown>;
-    getAll?(options?: Record<string, unknown>): Promise<unknown>;
-    delete?(memoryId: string, options?: Record<string, unknown>): Promise<unknown>;
-}
-interface Mem0MemoryAdapterOptions {
-    client: Mem0ClientLike;
-    mode: Mem0ClientMode;
-    id?: string;
-    appId?: string;
-    infer?: boolean;
-    rerank?: boolean;
-    latestOnly?: boolean;
-    /** Bounds delayed-delete visibility checks and abandoned hosted-write recovery waits. */
-    ingestionTimeoutMs?: number;
-    pollIntervalMs?: number;
-    /** Stable deployment/account identity for cache-key helpers. Never put credentials here. */
-    backendRef?: string;
-    defaultScope?: AgentMemoryScope;
-}
-/** Connects both the hosted Mem0 client and the open-source `Memory` class. */
-declare function createMem0MemoryAdapter(options: Mem0MemoryAdapterOptions): AgentMemoryAdapter;
-/** Stable identity useful for dispatch/cache keys without exposing client credentials. */
-declare function mem0MemoryAdapterIdentity(options: Pick<Mem0MemoryAdapterOptions, 'mode' | 'id' | 'appId' | 'infer' | 'rerank' | 'latestOnly' | 'ingestionTimeoutMs' | 'pollIntervalMs' | 'defaultScope'> & {
-    backendRef: string;
-}): string;
-
-interface Neo4jAgentMemoryAdapterOptions {
-    client: object;
-    /** Match the transport passed to the official MemoryClient. */
-    transport: 'rest' | 'bridge';
-    /** Use Neo4j's whole-conversation context instead of query-based search. */
-    contextMode?: 'search' | 'native';
-    id?: string;
-    /** Assert that the client owns disposable external state for this exact branch. */
-    branchId?: string;
-}
-declare function createNeo4jAgentMemoryAdapter(options: Neo4jAgentMemoryAdapterOptions): AgentMemoryAdapter;
-
-declare const AgentMemoryKindSchema: z.ZodEnum<{
-    preference: "preference";
-    message: "message";
-    entity: "entity";
-    fact: "fact";
-    observation: "observation";
-    "reasoning-trace": "reasoning-trace";
-}>;
-declare const AgentMemoryScopeSchema: z.ZodObject<{
-    tenantId: z.ZodOptional<z.ZodString>;
-    userId: z.ZodOptional<z.ZodString>;
-    agentId: z.ZodOptional<z.ZodString>;
-    teamId: z.ZodOptional<z.ZodString>;
-    runId: z.ZodOptional<z.ZodString>;
-    sessionId: z.ZodOptional<z.ZodString>;
-    namespace: z.ZodOptional<z.ZodString>;
-    tags: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-}, z.core.$strip>;
-declare const AgentMemoryHitSchema: z.ZodObject<{
-    id: z.ZodString;
-    uri: z.ZodString;
-    kind: z.ZodEnum<{
-        preference: "preference";
-        message: "message";
-        entity: "entity";
-        fact: "fact";
-        observation: "observation";
-        "reasoning-trace": "reasoning-trace";
-    }>;
-    text: z.ZodString;
-    title: z.ZodOptional<z.ZodString>;
-    score: z.ZodOptional<z.ZodNumber>;
-    normalizedScore: z.ZodOptional<z.ZodNumber>;
-    confidence: z.ZodOptional<z.ZodNumber>;
-    createdAt: z.ZodOptional<z.ZodString>;
-    validUntil: z.ZodOptional<z.ZodString>;
-    lastVerifiedAt: z.ZodOptional<z.ZodString>;
-    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, z.core.$strip>;
-declare const AgentMemoryWriteInputSchema: z.ZodObject<{
-    kind: z.ZodEnum<{
-        preference: "preference";
-        message: "message";
-        entity: "entity";
-        fact: "fact";
-        observation: "observation";
-        "reasoning-trace": "reasoning-trace";
-    }>;
-    text: z.ZodString;
-    id: z.ZodOptional<z.ZodString>;
-    title: z.ZodOptional<z.ZodString>;
-    role: z.ZodOptional<z.ZodEnum<{
-        system: "system";
-        user: "user";
-        assistant: "assistant";
-        tool: "tool";
-    }>>;
-    entityName: z.ZodOptional<z.ZodString>;
-    entityType: z.ZodOptional<z.ZodString>;
-    category: z.ZodOptional<z.ZodString>;
-    predicate: z.ZodOptional<z.ZodString>;
-    subject: z.ZodOptional<z.ZodString>;
-    object: z.ZodOptional<z.ZodString>;
-    confidence: z.ZodOptional<z.ZodNumber>;
-    scope: z.ZodOptional<z.ZodObject<{
-        tenantId: z.ZodOptional<z.ZodString>;
-        userId: z.ZodOptional<z.ZodString>;
-        agentId: z.ZodOptional<z.ZodString>;
-        teamId: z.ZodOptional<z.ZodString>;
-        runId: z.ZodOptional<z.ZodString>;
-        sessionId: z.ZodOptional<z.ZodString>;
-        namespace: z.ZodOptional<z.ZodString>;
-        tags: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    }, z.core.$strip>>;
-    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, z.core.$strip>;
-
-declare function memoryHitToSourceRecord(hit: AgentMemoryHit, options?: {
-    now?: () => Date;
-    scope?: AgentMemoryScope;
-}): SourceRecord;
-declare function memoryWriteResultToSourceRecord(result: AgentMemoryWriteResult, text: string, options?: {
-    now?: () => Date;
-    scope?: AgentMemoryScope;
-}): SourceRecord;
-
-export { AgentMemoryAcquireRunLease, type AgentMemoryActivation, type AgentMemoryActivationDriver, AgentMemoryAdapter, type AgentMemoryAttemptEvent, type AgentMemoryBranch, type AgentMemoryBranchLifetime, type AgentMemoryBranchSnapshot, AgentMemoryContext, AgentMemoryControllerMode, type AgentMemoryDimensionComparison, type AgentMemoryExperimentCandidate, type AgentMemoryExperimentRankingRow, type AgentMemoryExperimentRunLease, type AgentMemoryGovernor, AgentMemoryHit, AgentMemoryHitSchema, type AgentMemoryImprovementRunLease, type AgentMemoryImprovementSeed, type AgentMemoryJournalEntry, AgentMemoryKindSchema, AgentMemoryLifecycleTimeoutError, AgentMemoryLifecycleUnsafeError, type AgentMemoryPromotionDecision, AgentMemoryRunLease, AgentMemoryScope, AgentMemoryScopeSchema, AgentMemorySearchOptions, type AgentMemorySequence, type AgentMemorySequenceArtifact, type AgentMemorySequenceProbe, type AgentMemorySequenceProbeResult, type AgentMemorySequenceScenario, type AgentMemorySequenceStep, type AgentMemorySharingPolicy, type AgentMemoryVisibility, AgentMemoryWriteInput, AgentMemoryWriteInputSchema, AgentMemoryWriteResult, type BuildAgentMemorySequencesFromBenchmarkCasesOptions, type CreateAgentMemoryBranchOptions, DEFAULT_MEMORY_CLEANUP_TIMEOUT_MS, type ForkAgentMemoryBranchSnapshotOptions, type GraphitiMcpClientLike, type GraphitiMemoryAdapterOptions, type GraphitiToolNames, type Mem0ClientLike, type Mem0ClientMode, type Mem0MemoryAdapterOptions, type Neo4jAgentMemoryAdapterOptions, RetrievalHoldoutBypassReason, RetrievalHoldoutCallContext, RetrievalHoldoutConfig, RetrievalHoldoutEvent, type RetrievalHoldoutOffPolicyOptions, type RetrievalHoldoutOffPolicyResult, RetrievalHoldoutResult, type RetrievalHoldoutSessionSummary, type RunAgentMemoryExperimentOptions, type RunAgentMemoryExperimentResult, type RunAgentMemoryImprovementOptions, type RunAgentMemoryImprovementResult, agentMemorySequenceJudge, applyRetrievalHoldout, applySessionStickyRetrievalHoldout, buildAgentMemorySequenceScenarios, buildAgentMemorySequencesFromBenchmarkCases, createAgentMemoryBranch, createGraphitiMemoryAdapter, createMem0MemoryAdapter, createMemoryExecutionPool, createNeo4jAgentMemoryAdapter, defaultGetMemoryContext, deterministicRng, emitRetrievalHoldoutBypass, forkAgentMemoryBranchSnapshot, graphitiMemoryAdapterIdentity, mem0MemoryAdapterIdentity, memoryHitToSourceRecord, memoryRecoveryDelayMs, memoryWriteResultToSourceRecord, renderMemoryContext, resetRetrievalHoldoutRegistry, resolveMemoryCleanupTimeoutMs, retrievalHoldoutConfigHash, runAgentMemoryExperiment, runAgentMemoryImprovement, runBoundedMemoryLifecycle, sleepForMemoryRecovery, toOffPolicyTrajectory };
+export { A as AgentMemoryActivation, b as AgentMemoryActivationDriver, c as AgentMemoryAttemptEvent, d as AgentMemoryBranch, e as AgentMemoryBranchLifetime, f as AgentMemoryBranchSnapshot, g as AgentMemoryDimensionComparison, h as AgentMemoryExecutionContext, i as AgentMemoryExecutionCostMeter, j as AgentMemoryExecutionCostReceipt, k as AgentMemoryExecutionPaidCallInput, l as AgentMemoryExecutionPaidCallResult, m as AgentMemoryExecutionStep, n as AgentMemoryExperimentCandidate, o as AgentMemoryExperimentRankingRow, p as AgentMemoryExperimentRunLease, q as AgentMemoryFinalEvaluation, r as AgentMemoryFinalPair, s as AgentMemoryHitSchema, t as AgentMemoryImprovementRunLease, u as AgentMemoryJournalEntry, v as AgentMemoryKindSchema, w as AgentMemoryLifecycleTimeoutError, x as AgentMemoryLifecycleUnsafeError, y as AgentMemoryPromotionDecision, z as AgentMemoryScopeSchema, B as AgentMemorySequence, C as AgentMemorySequenceArtifact, D as AgentMemorySequenceProbe, E as AgentMemorySequenceProbeResult, F as AgentMemorySequenceScenario, G as AgentMemorySequenceStep, H as AgentMemorySharingPolicy, I as AgentMemoryVisibility, J as AgentMemoryWriteInputSchema, K as BuildAgentMemorySequencesFromBenchmarkCasesOptions, L as CreateAgentMemoryBranchOptions, M as DEFAULT_MEMORY_CLEANUP_TIMEOUT_MS, N as ForkAgentMemoryBranchSnapshotOptions, O as GraphitiMcpClientLike, P as GraphitiMemoryAdapterOptions, Q as GraphitiToolNames, S as Mem0ClientLike, T as Mem0ClientMode, U as Mem0MemoryAdapterOptions, V as MemoryConfigScenario, W as Neo4jAgentMemoryAdapterOptions, X as RetrievalHoldoutOffPolicyOptions, Y as RetrievalHoldoutOffPolicyResult, Z as RetrievalHoldoutSessionSummary, _ as RunAgentMemoryExperimentOptions, $ as RunAgentMemoryExperimentResult, a0 as RunAgentMemoryImprovementOptions, a1 as RunAgentMemoryImprovementResult, a4 as agentMemorySequenceJudge, a5 as applyRetrievalHoldout, a6 as applySessionStickyRetrievalHoldout, a7 as buildAgentMemorySequenceScenarios, a8 as buildAgentMemorySequencesFromBenchmarkCases, a9 as createAgentMemoryBranch, aa as createGraphitiMemoryAdapter, ab as createMem0MemoryAdapter, ac as createMemoryExecutionPool, ad as createNeo4jAgentMemoryAdapter, ae as defaultGetMemoryContext, af as deterministicRng, ag as emitRetrievalHoldoutBypass, ah as forkAgentMemoryBranchSnapshot, ai as graphitiMemoryAdapterIdentity, al as mem0MemoryAdapterIdentity, am as memoryHitToSourceRecord, an as memoryRecoveryDelayMs, ao as memoryWriteResultToSourceRecord, ap as renderMemoryContext, aq as resetRetrievalHoldoutRegistry, ar as resolveMemoryCleanupTimeoutMs, as as retrievalHoldoutConfigHash, at as runAgentMemoryExperiment, au as runAgentMemoryImprovement, av as runBoundedMemoryLifecycle, ay as sleepForMemoryRecovery, az as toOffPolicyTrajectory } from '../index-Cf7txrYP.js';
+export { A as AgentMemoryAcquireRunLease, f as AgentMemoryAdapter, g as AgentMemoryBranchIsolation, h as AgentMemoryContext, i as AgentMemoryControllerMode, j as AgentMemoryHit, k as AgentMemoryKind, l as AgentMemoryRunLease, m as AgentMemoryScope, n as AgentMemorySearchOptions, o as AgentMemoryWriteInput, p as AgentMemoryWriteResult, U as OwnedAgentMemoryRunLease, Z as RetrievalHoldoutBypassReason, _ as RetrievalHoldoutCallContext, $ as RetrievalHoldoutConfig, a0 as RetrievalHoldoutEligibleItem, a1 as RetrievalHoldoutEvent, a2 as RetrievalHoldoutResult, a3 as RetrievalHoldoutSessionState, ac as acquireAgentMemoryRunLease } from '../types-BY-xLVw-.js';
+import '@tangle-network/agent-eval/campaign';
+import '@tangle-network/agent-eval';
+import '@tangle-network/agent-eval/rl';
+import '@tangle-network/agent-interface';
+import 'zod';
+import '../types-6x0OpfW6.js';