import { type FailureCaptureProvenance, type SkillDefinition } from './definition.js';
import { type RepairProcessWitness } from './repair-process.js';
export type SkillRunState = 'running' | 'succeeded' | 'failed' | 'unknown';
export interface SkillRunStep {
    id: string;
    state: 'succeeded' | 'failed' | 'unknown';
    detail?: string;
}
export interface SkillRun {
    id: string;
    invocationId: string;
    goalId: string;
    sessionId: string;
    skillName: string;
    version: number;
    inputs: Readonly<Record<string, unknown>>;
    state: SkillRunState;
    steps: readonly SkillRunStep[];
    candidateId?: string;
    delegationDigest?: string;
    goalExecutionRunId?: string;
    goalDefinitionDigest?: string;
    nativeGoalId?: string;
    createdAt: number;
    updatedAt: number;
}
export interface SkillRunClaim {
    invocationId: string;
    goalId: string;
    sessionId: string;
    skillName: string;
    version: number;
    inputs: Readonly<Record<string, unknown>>;
    candidateId?: string;
    delegationDigest?: string;
    goalExecutionRunId?: string;
    goalDefinitionDigest?: string;
    nativeGoalId?: string;
}
/** A one-shot native benchmark arm. Its definition is never promoted into the skill directory. */
export interface SkillDelegatedArmBinding {
    protocol: 'assistant-skills/delegated-arm/v1';
    planDigest: string;
    cellId: string;
    variantId: string;
    definitionDigest: string;
    sourceDigest: string;
    recipientScopeDigest: string;
    skillName: string;
    version: number;
    expiresAt: number;
}
export interface StoredSkillDefinition extends SkillDefinition {
    version: number;
    parentVersion: number | null;
    retired: boolean;
    createdAt: number;
    updatedAt: number;
    restoredFromVersion?: number;
}
export interface SkillCandidate {
    id: string;
    definition: SkillDefinition;
    parentVersion: number;
    parentDigest: string | null;
    reason: string;
    trigger: string;
    failureProvenance?: FailureCaptureProvenance;
    expiresAt: number;
    state: 'pending' | 'activated' | 'rejected';
    createdAt: number;
    updatedAt: number;
    activatedVersion?: number;
    trialRunId?: string;
    activationComparisonId?: string;
    deploymentId?: string;
    acceptanceDigest?: string;
    activationWatchDigest?: string;
    activationWatchId?: string;
}
export interface SkillComparisonIdentity {
    sessionId: string;
    candidateId: string;
    parentDigest: string;
    profileId: string;
    profileDigest: string;
    invocationId: string;
}
export interface SkillComparison extends SkillComparisonIdentity {
    id: string;
    state: 'running' | 'complete' | 'unknown';
    result: unknown | null;
    createdAt: number;
    updatedAt: number;
}
export type SkillWatchProofVersion = 'sole-skill-run/v1' | 'canonical-goal-outcome/v2';
export interface SkillWatchTaskFamily {
    goalDefinitionDigest: string;
    outcomeProfile: {
        id: string;
        version: number;
        digest: string;
    };
}
export interface SkillWatchCanonicalRevision {
    subjectKind: 'goal-outcome';
    subjectRef: string;
    version: number;
    digest: string;
    disposition: 'upsert' | 'retract';
    scopeWatermark: number;
}
export interface SkillWatchObservationBinding {
    runId: string;
    subjectRef: string;
    receiptDigest: string;
    verifiedAt: number;
    validUntil: number;
    executionTraceDigest: string;
    taskFamilyDigest: string;
}
export interface SkillWatchObservation {
    runId: string;
    receiptDigest: string;
    objectiveStatus: 'achieved' | 'not-achieved';
    verifiedAt: number;
    validUntil: number;
    executionTraceDigest: string;
    taskFamilyDigest?: string;
    canonical?: SkillWatchCanonicalRevision;
}
export type SkillWatchObservationResult = Readonly<{
    kind: 'current';
    observation: SkillWatchObservation & {
        canonical: SkillWatchCanonicalRevision;
    };
    binding?: SkillWatchObservationBinding;
}> | Readonly<{
    kind: 'invalidated';
    runId: string;
    canonical: SkillWatchCanonicalRevision;
    binding?: SkillWatchObservationBinding;
}>;
export interface SkillWatchCanonicalState extends SkillWatchCanonicalRevision {
    runId: string;
    binding: SkillWatchObservationBinding;
}
export interface SkillWatch {
    id: string;
    scope: object;
    routeReceipt: unknown;
    afterRunRowId: number;
    ownerRouteId: string;
    skillName: string;
    version: number;
    definitionDigest: string;
    fallbackVersion: number;
    fallbackDigest: string;
    expiresAt: number;
    maxRuns: number;
    failureThreshold: number;
    state: 'watching' | 'rolled-back' | 'expired' | 'revoked' | 'superseded' | 'exhausted';
    runIds: readonly string[];
    observations: readonly SkillWatchObservation[];
    canonicalRevisions?: readonly SkillWatchCanonicalState[];
    createdAt: number;
    updatedAt: number;
    rollbackVersion?: number;
    proofVersion?: SkillWatchProofVersion;
    taskFamily?: SkillWatchTaskFamily;
}
export interface SkillWatchInput {
    ownerRouteId: string;
    skillName: string;
    version: number;
    fallbackVersion: number;
    expiresAt: number;
    maxRuns: number;
    failureThreshold: number;
}
export interface SkillDeploymentInput {
    ownerRouteId: string;
    expiresAt: number;
    maxRuns: number;
    canaryRuns: number;
}
export interface SkillDeploymentAdmission {
    protocol: 'assistant-skills/canary-admission/v1';
    skillName: string;
    parentDefinitionDigest: string;
    candidateDefinitionDigest: string;
    taskFamily: SkillWatchTaskFamily;
}
export interface SkillDeployment {
    id: string;
    scope: object;
    candidateId: string;
    comparisonId: string;
    qualificationDigest: string;
    admissionDigest: string;
    candidateDefinitionDigest: string;
    routeReceipt: unknown;
    ownerRouteId: string;
    skillName: string;
    version: number;
    definitionDigest: string;
    parentVersion: number;
    watchId: string;
    taskFamily: SkillWatchTaskFamily;
    expiresAt: number;
    maxRuns: number;
    canaryRuns: number;
    runIds: string[];
    state: 'canary' | 'promoted' | 'blocked' | 'expired' | 'revoked' | 'rolled-back' | 'superseded';
    createdAt: number;
    updatedAt: number;
    promotedAt?: number;
}
export interface SkillCapture {
    id: string;
    scope: object;
    routeReceipt: unknown;
    ownerRouteId: string;
    goalId: string;
    sessionId: string;
    nativeGoalId: string;
    name: string;
    description: string;
    parentVersion: number;
    parentDigest: string | null;
    definitionDigest: string;
    expiresAt: number;
    state: 'pending' | 'captured' | 'revoked' | 'expired' | 'unsupported' | 'unknown';
    candidateId?: string;
    detail?: string;
    createdAt: number;
    updatedAt: number;
}
export interface SkillCaptureInput {
    ownerRouteId: string;
    goalId: string;
    sessionId: string;
    nativeGoalId: string;
    name: string;
    description: string;
    parentVersion: number;
    expiresAt: number;
}
export interface SkillCandidateOptions {
    expectedVersion: number;
    reason: string;
    trigger: string;
    expiresAt: number;
    failureProvenance?: FailureCaptureProvenance;
}
export type SkillRepairState = 'armed' | 'source-confirmed' | 'creating-repair' | 'repairing' | 'repair-achieved' | 'capturing' | 'candidate-staged' | 'comparing' | 'watching' | 'complete' | 'rejected' | 'revoked' | 'expired' | 'unknown';
export interface SkillRepairAuthorizationInput {
    invocationId: string;
    ownerRouteId: string;
    source: {
        goalId: string;
        sessionId: string;
        nativeGoalId: string;
        definitionDigest: string;
    };
    profileId: string;
    profileDigest: string;
    skillName: string;
    parentVersion: number;
    parentDigest: string;
    maxIterations: number;
    expiresAt: number;
    /** Frozen at arm time. Undefined is accepted only for legacy fixed-route records. */
    modelSelection?: {
        provider: string;
        model: string;
        reasoningEffort?: string;
    };
    profileSequence?: readonly {
        id: string;
        digest: string;
    }[];
    feedbackAuthority?: {
        sessionId: string;
        expiresAt: number;
        routeReceipt: unknown;
    };
}
export interface SkillRepairNextIterationInput {
    profileId: string;
    source: {
        goalId: string;
        sessionId: string;
        nativeGoalId: string;
        definitionDigest: string;
    };
    trigger: unknown;
    predecessorDeploymentId: string;
}
export interface SkillRepairContinuation {
    id: string;
    scope: object;
    authorization: SkillRepairAuthorizationInput;
    authorizationDigest: string;
    routeReceipt: unknown;
    iteration: number;
    revision: number;
    state: SkillRepairState;
    checkpoint: Readonly<Record<string, unknown>>;
    createdAt: number;
    updatedAt: number;
}
export interface RepairExecutionLease {
    authorizationId: string;
    authorizationDigest: string;
    iteration: number;
    sessionId: string;
    holderId: string;
    fence: number;
    deadlineAt: number;
    process: RepairProcessWitness;
    state: 'active' | 'released';
    pendingModel: number;
    pendingTool: number;
}
/** Owner-scoped immutable definitions and no-replay invocation receipts. */
export declare class SkillStore {
    #private;
    constructor(path: string);
    close(): void;
    reserveDelegatedArm(scope: object, binding: SkillDelegatedArmBinding): void;
    inspectRepairExecution(scope: object, id: string, iteration: number): RepairExecutionLease | undefined;
    claimRepairExecution(scope: object, id: string, iteration: number, sessionId: string, holderId: string, deadlineAt: number, options: {
        recover: boolean;
    }): RepairExecutionLease;
    assertRepairExecution(scope: object, lease: RepairExecutionLease): void;
    beginRepairEffect(scope: object, lease: RepairExecutionLease, kind: 'model' | 'tool'): () => void;
    releaseRepairExecution(scope: object, lease: RepairExecutionLease): void;
    createRepairContinuation(scope: object, input: SkillRepairAuthorizationInput, routeReceipt: unknown): SkillRepairContinuation;
    repairUsage(scope: object, id: string): {
        modelCalls: number;
        toolCalls: number;
    };
    chargeRepairUsage(scope: object, id: string, kind: 'model' | 'tool', limit: number): {
        modelCalls: number;
        toolCalls: number;
    };
    getRepairContinuation(scope: object, id: string): SkillRepairContinuation | undefined;
    listRepairContinuations(scope?: object): SkillRepairContinuation[];
    repairSourceRuns(scope: object, skillName: string, skillVersion: number, since: number): readonly SkillRun[];
    transitionRepairContinuation(scope: object, id: string, expectedRevision: number, nextState: SkillRepairState, checkpoint: Readonly<Record<string, unknown>>): SkillRepairContinuation;
    nextRepairIteration(scope: object, id: string, expectedRevision: number, input: SkillRepairNextIterationInput): SkillRepairContinuation;
    save(scope: object, definition: SkillDefinition, expectedVersion?: number): StoredSkillDefinition;
    list(scope: object): StoredSkillDefinition[];
    get(scope: object, skillName: string, wantedVersion?: number): StoredSkillDefinition | undefined;
    retire(scope: object, skillName: string, expectedVersion: number): StoredSkillDefinition;
    stageCandidate(scope: object, definition: SkillDefinition, options: SkillCandidateOptions): SkillCandidate;
    getCandidate(scope: object, id: string): SkillCandidate | undefined;
    listCandidates(scope: object): SkillCandidate[];
    createCapture(scope: object, input: SkillCaptureInput, routeReceipt: unknown, definitionDigest: string): SkillCapture;
    listCaptures(scope?: object): SkillCapture[];
    finishCapture(scope: object, id: string, state: Exclude<SkillCapture['state'], 'pending' | 'captured'>, detail?: string): SkillCapture;
    captureCandidate(scope: object, id: string, definition: SkillDefinition): SkillCapture;
    rejectCandidate(scope: object, id: string): SkillCandidate;
    activateCandidate(scope: object, id: string, trialRunId: string, receipt: string, watch?: {
        input: SkillWatchInput;
        routeReceipt: unknown;
    }): StoredSkillDefinition;
    activateQualifiedCandidate(scope: object, candidateId: string, comparisonId: string, qualificationDigest: string, admission: SkillDeploymentAdmission, input: SkillDeploymentInput, routeReceipt: unknown): {
        definition: StoredSkillDefinition;
        deployment: SkillDeployment;
    };
    getDeployment(scope: object, id: string): SkillDeployment | undefined;
    deploymentForVersion(scope: object, skillName: string, wantedVersion: number): SkillDeployment | undefined;
    listDeployments(scope?: object): SkillDeployment[];
    reconcileDeployment(scope: object, id: string): SkillDeployment | undefined;
    /** Promotion-capable reconciliation; call only while holding Evaluation's exact canonical writer fence. */
    reconcileDeploymentWithCanonicalPromotion(scope: object, id: string): SkillDeployment | undefined;
    stopDeployment(scope: object, id: string, state: Extract<SkillDeployment['state'], 'blocked' | 'revoked'>): SkillDeployment | undefined;
    assertDeploymentRun(scope: object, id: string): SkillDeployment;
    rollback(scope: object, skillName: string, expectedVersion: number, targetVersion: number): StoredSkillDefinition;
    createWatch(scope: object, input: SkillWatchInput, routeReceipt: unknown): SkillWatch;
    listWatches(scope?: object): SkillWatch[];
    observeWatch(scope: object, id: string, observation: SkillWatchObservation): SkillWatch | undefined;
    replaceWatchObservation(scope: object, id: string, result: SkillWatchObservationResult): SkillWatch | undefined;
    /** Commit the canonical replacement, deployment transition and any required exact-version rollback in one writer transaction. */
    replaceWatchObservationAndRollback(scope: object, id: string, result: SkillWatchObservationResult): SkillWatch | undefined;
    /** Commit a positive canonical replacement and promotion-only reconciliation under one Evaluation writer fence. */
    replaceWatchObservationAndPromote(scope: object, id: string, deploymentId: string, result: SkillWatchObservationResult): {
        watch: SkillWatch;
        deployment: SkillDeployment;
    };
    stopWatch(scope: object, id: string, state: Extract<SkillWatch['state'], 'expired' | 'revoked' | 'superseded' | 'exhausted'>): SkillWatch | undefined;
    rollbackWatch(scope: object, id: string): SkillWatch | undefined;
    claim(scope: object, input: SkillRunClaim): {
        claimed: boolean;
        run: SkillRun;
    };
    claimDelegated(scope: object, input: SkillRunClaim, bindingDigest: string): {
        claimed: boolean;
        run: SkillRun;
    };
    finish(scope: object, id: string, state: Exclude<SkillRunState, 'running'>, steps: readonly SkillRunStep[]): SkillRun;
    checkpoint(scope: object, id: string, steps: readonly SkillRunStep[]): SkillRun;
    getRun(scope: object, id: string): SkillRun | undefined;
    claimComparison(scope: object, identity: SkillComparisonIdentity, maxComparisons: number): {
        claimed: boolean;
        comparison: SkillComparison;
    };
    getComparison(scope: object, id: string): SkillComparison | undefined;
    finishComparison(scope: object, id: string, state: 'complete' | 'unknown', result: unknown): SkillComparison;
}
//# sourceMappingURL=store.d.ts.map