import { Context, Service } from '@deepseek-ai/cordis';
import type { Agent } from '@deepseek-ai/dsh-agent';
import type { ToolRunContext } from '@deepseek-ai/dsh-tools';
import type { GoalScope, OwnerAuthorizedRepairInput, OwnerAuthorizedRepairResumeInput } from '@dsh-enhanced/assistant-goals';
import Schema from '@deepseek-ai/schemastery';
import { type SkillBinding } from './definition.js';
import { type SkillComparisonProfile } from './comparison.js';
import { type SealedSkillHoldoutProvider } from './sealed-holdout.js';
import { type ExternalHoldoutProfile } from './external-holdout.js';
import { type RepairContinuationProfile } from './repair-profile.js';
import { type SkillRun, type SkillRunStep, type StoredSkillDefinition, type SkillDeploymentInput } from './store.js';
import { type BenchmarkArmSelection, type BenchmarkArmSnapshot, type BenchmarkArmCapability, type BenchmarkArmMount } from './delegated-arm.js';
import type { SkillDelegatedArmBinding } from './store.js';
export interface Config {
    databasePath?: string;
    allowedTools?: string[];
    maxDurationMs?: number;
    candidateTtlMs?: number;
    comparisons?: SkillComparisonProfile[];
    externalHoldouts?: ExternalHoldoutProfile[];
    repairProfiles?: RepairContinuationProfile[];
}
/** Narrow Host-only capability for a finite continuation of a prior owner authorization. */
export interface RepairExecutionAuthority {
    readonly id: string;
    readonly scope: GoalScope;
    readonly ownerRouteId: string;
    readonly expiresAt: number;
    assertCurrent(): void;
}
/**
 * Host-only capability for a single autonomous growth deposit.  It has the
 * same narrow shape as a repair authority, but it is NOT backed by a repair
 * continuation record: the growth driver mints it from a frozen configured
 * owner scope for one bounded wake only.  It can draft a pending candidate and
 * nothing else — never save/activate/install/retire/rollback.
 */
export interface OwnerSuccessCandidateAuthority {
    readonly id: string;
    readonly scope: GoalScope;
    readonly ownerRouteId: string;
    readonly expiresAt: number;
    assertCurrent(): void;
}
export type RepairExecutionContext = Pick<ToolRunContext, 'agent' | 'signal'>;
export interface StageFailureCandidateInput {
    readonly ownerRouteId: string;
    readonly triggerGoalId?: string;
    readonly triggerSessionId?: string;
    readonly failureLocators?: unknown;
    readonly minimumOccurrences?: number;
    readonly repairGoalId: string;
    readonly repairSessionId: string;
    readonly taskFamilyId: string;
    readonly name: string;
    readonly description: string;
    readonly bindings?: readonly SkillBinding[];
    readonly parentVersion: number;
}
/**
 * Owner-anchored autonomous success deposit.  Locators are model-suggested
 * discovery hints only; the Host re-derives every source through
 * goals.inspectOwnerVerifiedWorkflowSource, so a model cannot forge evidence.
 * parentVersion is deliberately absent: the Host resolves the current parent.
 */
export interface StageSuccessCandidateInput {
    readonly ownerRouteId: string;
    readonly successLocators: unknown;
    readonly minimumOccurrences?: number;
    readonly name: string;
    readonly description: string;
    readonly bindings?: readonly SkillBinding[];
}
export declare const Config: Schema<Config>;
declare module '@deepseek-ai/cordis' {
    interface Context {
        assistantSkills: AssistantSkillsService;
    }
}
/** Fixed tool compositions run in the original native Goal; no new AgentLoop or scheduler. */
export declare class AssistantSkillsService extends Service {
    #private;
    static Config: Schema<Config>;
    /** A Host identity only; it carries no permission and survives fresh Cordis trace proxies. */
    benchmarkRecipientIdentity: () => object;
    constructor(ctx: Context, config?: Config);
    /** Host-only registration; there is intentionally no model tool for sealed inputs or attestations. */
    registerSealedHoldoutProvider: (provider: SealedSkillHoldoutProvider) => (() => void);
    inspectSealedHoldout: (planId: string, scope: GoalScope) => Readonly<{
        protocol: "assistant-skills/sealed-holdout-binding/v1";
        planId: string;
        bindingDigest: string;
        attestationDigest: string;
    }>;
    /** Host-only immutable configuration inspection for a previously authorized repair. */
    inspectRepairProfile: (profileId: string, scope: GoalScope) => Readonly<{
        profile: ExternalHoldoutProfile;
        digest: string;
        templateDigest: string | undefined;
    }> | undefined;
    /** Host-only current definition read; callers must bind its digest in durable intent. */
    inspectRepairParent: (scope: GoalScope, name: string) => StoredSkillDefinition | undefined;
    /** Host entrypoint: consumes opaque provider cases through the same native replay and isolated verifier as compare. */
    qualifySealedHoldout: (exec: ToolRunContext, candidateId: string, planId: string, invocationId: string) => Promise<import("./store.js").SkillComparison>;
    save(agent: Agent | undefined, goalId: string, options: {
        name: string;
        description: string;
        bindings?: readonly SkillBinding[];
    }, expectedVersion?: number): StoredSkillDefinition;
    inspect(agent: Agent | undefined, runId?: string): SkillRun | StoredSkillDefinition[] | {
        delegation: SkillDelegatedArmBinding;
        delegationDigest: string;
        version: number;
        parentVersion: number | null;
        retired: boolean;
        createdAt: number;
        updatedAt: number;
        restoredFromVersion?: number;
        protocol: "assistant-skills/definition/v1";
        name: string;
        description: string;
        source: import("@dsh-enhanced/assistant-goals").VerifiedWorkflowSource;
        inputs: readonly import("./definition.js").SkillInput[];
        steps: readonly import("./definition.js").SkillStep[];
        fileObservations?: import("./definition.js").SkillFileObservations;
        runExpansions?: readonly import("./definition.js").SkillRunExpansion[];
        preconditions: import("./definition.js").SkillPreconditionKind;
        compensation: import("./definition.js").SkillCompensationKind;
    }[] | undefined;
    retire(agent: Agent | undefined, name: string, expectedVersion: number): StoredSkillDefinition;
    comparisonStatus(agent: Agent | undefined, id?: string): {
        generatorDigest?: unknown;
        admissionDigest?: {} | null;
        planDigest?: unknown;
        datasetDigest?: unknown;
        quality?: {
            candidateChecksPassed: unknown;
            evaluationGain: unknown;
            evaluationGainObserved: unknown;
            criticalRegressionsPassed: unknown;
            heldoutIndependence: unknown;
        };
        id: string;
        candidateId: string;
        parentDigest: string;
        profileId: string;
        profileDigest: string;
        invocationId: string;
        state: "running" | "unknown" | "complete";
        createdAt: number;
        updatedAt: number;
    } | ({
        id: string;
        version: number;
        kind: string;
        executionTool: string;
        expiresAt: number;
        cases: number;
        repeats: number;
        maxComparisons: number;
    } | {
        expiresAt: number;
        maxComparisons: 1;
        canaryExecutionTool?: string;
        id: string;
        version: number;
        kind: string;
        executionTool: string;
    })[] | null;
    /** Fixed external authority qualification. Private cells, authority keys and operator configuration never become tool arguments or status data. */
    qualifyExternalHoldout(exec: RepairExecutionContext, candidateId: string, profileId: string, invocationId: string, action?: 'compare' | 'canary', currentAuthority?: () => void, repair?: {
        authority: RepairExecutionAuthority;
        profile: ExternalHoldoutProfile;
        configuredDigest: string;
    }): Promise<{
        generatorDigest?: unknown;
        admissionDigest?: {} | null;
        planDigest?: unknown;
        datasetDigest?: unknown;
        quality?: {
            candidateChecksPassed: unknown;
            evaluationGain: unknown;
            evaluationGainObserved: unknown;
            criticalRegressionsPassed: unknown;
            heldoutIndependence: unknown;
        };
        id: string;
        candidateId: string;
        parentDigest: string;
        profileId: string;
        profileDigest: string;
        invocationId: string;
        state: "running" | "unknown" | "complete";
        createdAt: number;
        updatedAt: number;
    }>;
    canary(exec: RepairExecutionContext, candidateId: string, profileId: string, invocationId: string, input: SkillDeploymentInput, repair?: RepairExecutionAuthority): Promise<{
        definition: {
            restoredFromVersion?: number;
            version?: number;
            parentVersion?: number | null;
            retired?: boolean;
            definitionDigest?: string;
            createdAt?: number;
            updatedAt?: number;
            preconditions: "current-owner-policy-and-fresh-goal";
            compensation: "stop-and-report";
            runExpansionCount?: number;
            runExpansionsDigest?: string;
            fileObservations?: import("./definition.js").SkillFileObservations;
            protocol: "assistant-skills/definition/v1";
            name: string;
            description: string;
            source: {
                digest: string;
                goalDefinitionDigest: string;
                stepCount: number;
                failedObservationCount: number;
                segmentCount: number;
            };
            inputs: readonly import("./definition.js").SkillInput[];
            steps: readonly import("./definition.js").SkillStep[];
        };
        deployment: {
            id: string;
            candidateId: string;
            comparisonId: string;
            qualificationDigest: string;
            admissionDigest: string;
            candidateDefinitionDigest: string;
            skillName: string;
            version: number;
            definitionDigest: string;
            parentVersion: number;
            watchId: string;
            taskFamilyDigest: string;
            expiresAt: number;
            maxRuns: number;
            canaryRuns: number;
            runCount: number;
            state: "rolled-back" | "expired" | "revoked" | "superseded" | "canary" | "promoted" | "blocked";
            createdAt: number;
            updatedAt: number;
        };
        replayed: boolean;
    }>;
    /** Host-only repair continuation. It requires a dynamic template, never a model-visible admission. */
    canaryOwnerAuthorizedRepair: (exec: RepairExecutionContext, candidateId: string, profileId: string, invocationId: string, deploymentInput: SkillDeploymentInput, authority: RepairExecutionAuthority) => Promise<{
        definition: {
            restoredFromVersion?: number;
            version?: number;
            parentVersion?: number | null;
            retired?: boolean;
            definitionDigest?: string;
            createdAt?: number;
            updatedAt?: number;
            preconditions: "current-owner-policy-and-fresh-goal";
            compensation: "stop-and-report";
            runExpansionCount?: number;
            runExpansionsDigest?: string;
            fileObservations?: import("./definition.js").SkillFileObservations;
            protocol: "assistant-skills/definition/v1";
            name: string;
            description: string;
            source: {
                digest: string;
                goalDefinitionDigest: string;
                stepCount: number;
                failedObservationCount: number;
                segmentCount: number;
            };
            inputs: readonly import("./definition.js").SkillInput[];
            steps: readonly import("./definition.js").SkillStep[];
        };
        deployment: {
            id: string;
            candidateId: string;
            comparisonId: string;
            qualificationDigest: string;
            admissionDigest: string;
            candidateDefinitionDigest: string;
            skillName: string;
            version: number;
            definitionDigest: string;
            parentVersion: number;
            watchId: string;
            taskFamilyDigest: string;
            expiresAt: number;
            maxRuns: number;
            canaryRuns: number;
            runCount: number;
            state: "rolled-back" | "expired" | "revoked" | "superseded" | "canary" | "promoted" | "blocked";
            createdAt: number;
            updatedAt: number;
        };
        replayed: boolean;
    }>;
    compare(exec: ToolRunContext, candidateId: string, profileId: string, invocationId: string): Promise<{
        generatorDigest?: unknown;
        admissionDigest?: {} | null;
        planDigest?: unknown;
        datasetDigest?: unknown;
        quality?: {
            candidateChecksPassed: unknown;
            evaluationGain: unknown;
            evaluationGainObserved: unknown;
            criticalRegressionsPassed: unknown;
            heldoutIndependence: unknown;
        };
        id: string;
        candidateId: string;
        parentDigest: string;
        profileId: string;
        profileDigest: string;
        invocationId: string;
        state: "running" | "unknown" | "complete";
        createdAt: number;
        updatedAt: number;
    }>;
    stage(agent: Agent | undefined, goalId: string, options: {
        name: string;
        description: string;
        bindings?: readonly SkillBinding[];
    }, parentVersion: number, reason: string, trigger: string): {
        comparison: {
            kind: string;
            improvement: string;
            toolsAdded: string[];
            toolsRemoved: string[];
            inputsChanged: boolean;
            changedSteps: {
                index: number;
                before: string | null;
                after: string | null;
            }[];
        };
        failure?: {
            protocol: "assistant-skills/failure-capture-provenance/v1";
            provenanceDigest: string;
            category: import("./definition.js").FailureCaptureCategory;
            occurrences: number;
            taskFamilyId: string;
            taskFamilyDefinitionDigest: string;
            permissionDelta: {
                parent: readonly string[];
                candidate: readonly string[];
                added: readonly string[];
                removed: readonly string[];
                expandsAuthority: boolean;
            };
            rollbackTarget: {
                name: string;
                version: number;
                digest: string;
            };
            count: number;
            digest: string;
        };
        activationWatchId?: string;
        deploymentId?: string;
        activationComparisonId?: string;
        activatedVersion?: number;
        id: string;
        definition: {
            restoredFromVersion?: number;
            version?: number;
            parentVersion?: number | null;
            retired?: boolean;
            definitionDigest?: string;
            createdAt?: number;
            updatedAt?: number;
            preconditions: "current-owner-policy-and-fresh-goal";
            compensation: "stop-and-report";
            runExpansionCount?: number;
            runExpansionsDigest?: string;
            fileObservations?: import("./definition.js").SkillFileObservations;
            protocol: "assistant-skills/definition/v1";
            name: string;
            description: string;
            source: {
                digest: string;
                goalDefinitionDigest: string;
                stepCount: number;
                failedObservationCount: number;
                segmentCount: number;
            };
            inputs: readonly import("./definition.js").SkillInput[];
            steps: readonly import("./definition.js").SkillStep[];
        };
        definitionDigest: string;
        parentVersion: number;
        parentDigest: string | null;
        reason: string;
        trigger: string;
        expiresAt: number;
        state: "pending" | "activated" | "rejected";
        createdAt: number;
        updatedAt: number;
    };
    stageFailureCandidate(exec: RepairExecutionContext, input: StageFailureCandidateInput, repair?: RepairExecutionAuthority): Promise<{
        comparison: {
            kind: string;
            improvement: string;
            toolsAdded: string[];
            toolsRemoved: string[];
            inputsChanged: boolean;
            changedSteps: {
                index: number;
                before: string | null;
                after: string | null;
            }[];
        };
        failure?: {
            protocol: "assistant-skills/failure-capture-provenance/v1";
            provenanceDigest: string;
            category: import("./definition.js").FailureCaptureCategory;
            occurrences: number;
            taskFamilyId: string;
            taskFamilyDefinitionDigest: string;
            permissionDelta: {
                parent: readonly string[];
                candidate: readonly string[];
                added: readonly string[];
                removed: readonly string[];
                expandsAuthority: boolean;
            };
            rollbackTarget: {
                name: string;
                version: number;
                digest: string;
            };
            count: number;
            digest: string;
        };
        activationWatchId?: string;
        deploymentId?: string;
        activationComparisonId?: string;
        activatedVersion?: number;
        id: string;
        definition: {
            restoredFromVersion?: number;
            version?: number;
            parentVersion?: number | null;
            retired?: boolean;
            definitionDigest?: string;
            createdAt?: number;
            updatedAt?: number;
            preconditions: "current-owner-policy-and-fresh-goal";
            compensation: "stop-and-report";
            runExpansionCount?: number;
            runExpansionsDigest?: string;
            fileObservations?: import("./definition.js").SkillFileObservations;
            protocol: "assistant-skills/definition/v1";
            name: string;
            description: string;
            source: {
                digest: string;
                goalDefinitionDigest: string;
                stepCount: number;
                failedObservationCount: number;
                segmentCount: number;
            };
            inputs: readonly import("./definition.js").SkillInput[];
            steps: readonly import("./definition.js").SkillStep[];
        };
        definitionDigest: string;
        parentVersion: number;
        parentDigest: string | null;
        reason: string;
        trigger: string;
        expiresAt: number;
        state: "pending" | "activated" | "rejected";
        createdAt: number;
        updatedAt: number;
    }>;
    stageOwnerAuthorizedFailureCandidate: (exec: RepairExecutionContext, input: StageFailureCandidateInput, authority: RepairExecutionAuthority) => Promise<{
        comparison: {
            kind: string;
            improvement: string;
            toolsAdded: string[];
            toolsRemoved: string[];
            inputsChanged: boolean;
            changedSteps: {
                index: number;
                before: string | null;
                after: string | null;
            }[];
        };
        failure?: {
            protocol: "assistant-skills/failure-capture-provenance/v1";
            provenanceDigest: string;
            category: import("./definition.js").FailureCaptureCategory;
            occurrences: number;
            taskFamilyId: string;
            taskFamilyDefinitionDigest: string;
            permissionDelta: {
                parent: readonly string[];
                candidate: readonly string[];
                added: readonly string[];
                removed: readonly string[];
                expandsAuthority: boolean;
            };
            rollbackTarget: {
                name: string;
                version: number;
                digest: string;
            };
            count: number;
            digest: string;
        };
        activationWatchId?: string;
        deploymentId?: string;
        activationComparisonId?: string;
        activatedVersion?: number;
        id: string;
        definition: {
            restoredFromVersion?: number;
            version?: number;
            parentVersion?: number | null;
            retired?: boolean;
            definitionDigest?: string;
            createdAt?: number;
            updatedAt?: number;
            preconditions: "current-owner-policy-and-fresh-goal";
            compensation: "stop-and-report";
            runExpansionCount?: number;
            runExpansionsDigest?: string;
            fileObservations?: import("./definition.js").SkillFileObservations;
            protocol: "assistant-skills/definition/v1";
            name: string;
            description: string;
            source: {
                digest: string;
                goalDefinitionDigest: string;
                stepCount: number;
                failedObservationCount: number;
                segmentCount: number;
            };
            inputs: readonly import("./definition.js").SkillInput[];
            steps: readonly import("./definition.js").SkillStep[];
        };
        definitionDigest: string;
        parentVersion: number;
        parentDigest: string | null;
        reason: string;
        trigger: string;
        expiresAt: number;
        state: "pending" | "activated" | "rejected";
        createdAt: number;
        updatedAt: number;
    }>;
    /**
     * Host-only autonomous SUCCESS deposit for the growth driver.  Unlike the
     * repair/failure path it is deliberately NOT anchored to a durable repair
     * continuation: a successful goal creates none.  Instead the caller supplies
     * a narrow, short-lived OwnerSuccessCandidateAuthority minted from a frozen
     * configured owner scope, and this method:
     *   1. validates the authority (live background agent, exact scope, unexpired,
     *      caller assertCurrent lease) and re-anchors the authenticated owner route
     *      through delivery.validateOwnerRoute — never trusting a model-supplied id;
     *   2. independently re-reads EVERY model-suggested locator through
     *      goals.inspectOwnerVerifiedWorkflowSource (owner-root, succeeded,
     *      quiescent, double-read), counting DISTINCT (sessionId,goalId);
     *   3. stages one PENDING candidate only when the distinct verified-success
     *      count meets minimumOccurrences.  It never writes a current version, so
     *      skill_run cannot reach it; activation stays behind the existing owner
     *      gates.  A retired same-name skill or any version conflict fails closed.
     */
    stageOwnerVerifiedSuccessCandidate(exec: RepairExecutionContext, rawInput: StageSuccessCandidateInput, authority: OwnerSuccessCandidateAuthority): Promise<{
        comparison: {
            kind: string;
            improvement: string;
            toolsAdded: string[];
            toolsRemoved: string[];
            inputsChanged: boolean;
            changedSteps: {
                index: number;
                before: string | null;
                after: string | null;
            }[];
        };
        failure?: {
            protocol: "assistant-skills/failure-capture-provenance/v1";
            provenanceDigest: string;
            category: import("./definition.js").FailureCaptureCategory;
            occurrences: number;
            taskFamilyId: string;
            taskFamilyDefinitionDigest: string;
            permissionDelta: {
                parent: readonly string[];
                candidate: readonly string[];
                added: readonly string[];
                removed: readonly string[];
                expandsAuthority: boolean;
            };
            rollbackTarget: {
                name: string;
                version: number;
                digest: string;
            };
            count: number;
            digest: string;
        };
        activationWatchId?: string;
        deploymentId?: string;
        activationComparisonId?: string;
        activatedVersion?: number;
        id: string;
        definition: {
            restoredFromVersion?: number;
            version?: number;
            parentVersion?: number | null;
            retired?: boolean;
            definitionDigest?: string;
            createdAt?: number;
            updatedAt?: number;
            preconditions: "current-owner-policy-and-fresh-goal";
            compensation: "stop-and-report";
            runExpansionCount?: number;
            runExpansionsDigest?: string;
            fileObservations?: import("./definition.js").SkillFileObservations;
            protocol: "assistant-skills/definition/v1";
            name: string;
            description: string;
            source: {
                digest: string;
                goalDefinitionDigest: string;
                stepCount: number;
                failedObservationCount: number;
                segmentCount: number;
            };
            inputs: readonly import("./definition.js").SkillInput[];
            steps: readonly import("./definition.js").SkillStep[];
        };
        definitionDigest: string;
        parentVersion: number;
        parentDigest: string | null;
        reason: string;
        trigger: string;
        expiresAt: number;
        state: "pending" | "activated" | "rejected";
        createdAt: number;
        updatedAt: number;
    }>;
    candidates(agent: Agent | undefined, id?: string): {
        comparison: {
            kind: string;
            improvement: string;
            toolsAdded: string[];
            toolsRemoved: string[];
            inputsChanged: boolean;
            changedSteps: {
                index: number;
                before: string | null;
                after: string | null;
            }[];
        };
        failure?: {
            protocol: "assistant-skills/failure-capture-provenance/v1";
            provenanceDigest: string;
            category: import("./definition.js").FailureCaptureCategory;
            occurrences: number;
            taskFamilyId: string;
            taskFamilyDefinitionDigest: string;
            permissionDelta: {
                parent: readonly string[];
                candidate: readonly string[];
                added: readonly string[];
                removed: readonly string[];
                expandsAuthority: boolean;
            };
            rollbackTarget: {
                name: string;
                version: number;
                digest: string;
            };
            count: number;
            digest: string;
        };
        activationWatchId?: string;
        deploymentId?: string;
        activationComparisonId?: string;
        activatedVersion?: number;
        id: string;
        definition: {
            restoredFromVersion?: number;
            version?: number;
            parentVersion?: number | null;
            retired?: boolean;
            definitionDigest?: string;
            createdAt?: number;
            updatedAt?: number;
            preconditions: "current-owner-policy-and-fresh-goal";
            compensation: "stop-and-report";
            runExpansionCount?: number;
            runExpansionsDigest?: string;
            fileObservations?: import("./definition.js").SkillFileObservations;
            protocol: "assistant-skills/definition/v1";
            name: string;
            description: string;
            source: {
                digest: string;
                goalDefinitionDigest: string;
                stepCount: number;
                failedObservationCount: number;
                segmentCount: number;
            };
            inputs: readonly import("./definition.js").SkillInput[];
            steps: readonly import("./definition.js").SkillStep[];
        };
        definitionDigest: string;
        parentVersion: number;
        parentDigest: string | null;
        reason: string;
        trigger: string;
        expiresAt: number;
        state: "pending" | "activated" | "rejected";
        createdAt: number;
        updatedAt: number;
    } | {
        comparison: {
            kind: string;
            improvement: string;
            toolsAdded: string[];
            toolsRemoved: string[];
            inputsChanged: boolean;
            changedSteps: {
                index: number;
                before: string | null;
                after: string | null;
            }[];
        };
        failure?: {
            protocol: "assistant-skills/failure-capture-provenance/v1";
            provenanceDigest: string;
            category: import("./definition.js").FailureCaptureCategory;
            occurrences: number;
            taskFamilyId: string;
            taskFamilyDefinitionDigest: string;
            permissionDelta: {
                parent: readonly string[];
                candidate: readonly string[];
                added: readonly string[];
                removed: readonly string[];
                expandsAuthority: boolean;
            };
            rollbackTarget: {
                name: string;
                version: number;
                digest: string;
            };
            count: number;
            digest: string;
        };
        activationWatchId?: string;
        deploymentId?: string;
        activationComparisonId?: string;
        activatedVersion?: number;
        id: string;
        definition: {
            restoredFromVersion?: number;
            version?: number;
            parentVersion?: number | null;
            retired?: boolean;
            definitionDigest?: string;
            createdAt?: number;
            updatedAt?: number;
            preconditions: "current-owner-policy-and-fresh-goal";
            compensation: "stop-and-report";
            runExpansionCount?: number;
            runExpansionsDigest?: string;
            fileObservations?: import("./definition.js").SkillFileObservations;
            protocol: "assistant-skills/definition/v1";
            name: string;
            description: string;
            source: {
                digest: string;
                goalDefinitionDigest: string;
                stepCount: number;
                failedObservationCount: number;
                segmentCount: number;
            };
            inputs: readonly import("./definition.js").SkillInput[];
            steps: readonly import("./definition.js").SkillStep[];
        };
        definitionDigest: string;
        parentVersion: number;
        parentDigest: string | null;
        reason: string;
        trigger: string;
        expiresAt: number;
        state: "pending" | "activated" | "rejected";
        createdAt: number;
        updatedAt: number;
    }[] | null;
    /**
     * Host-only read of the active current skills of a delivery-anchored owner
     * scope.  The caller MUST first establish the scope through
     * delivery.validateOwnerRoute (exact owner route); this enumeration consumes
     * no live owner turn and exists for bounded background growth agents.  It is
     * discovery-only and cannot write.
     */
    inspectOwnerActiveSkills(scope: GoalScope): {
        restoredFromVersion?: number;
        version?: number;
        parentVersion?: number | null;
        retired?: boolean;
        definitionDigest?: string;
        createdAt?: number;
        updatedAt?: number;
        preconditions: "current-owner-policy-and-fresh-goal";
        compensation: "stop-and-report";
        runExpansionCount?: number;
        runExpansionsDigest?: string;
        fileObservations?: import("./definition.js").SkillFileObservations;
        protocol: "assistant-skills/definition/v1";
        name: string;
        description: string;
        source: {
            digest: string;
            goalDefinitionDigest: string;
            stepCount: number;
            failedObservationCount: number;
            segmentCount: number;
        };
        inputs: readonly import("./definition.js").SkillInput[];
        steps: readonly import("./definition.js").SkillStep[];
    }[];
    /** Host-only read of every skill candidate of a delivery-anchored owner scope. */
    inspectOwnerSkillCandidates(scope: GoalScope): {
        comparison: {
            kind: string;
            improvement: string;
            toolsAdded: string[];
            toolsRemoved: string[];
            inputsChanged: boolean;
            changedSteps: {
                index: number;
                before: string | null;
                after: string | null;
            }[];
        };
        failure?: {
            protocol: "assistant-skills/failure-capture-provenance/v1";
            provenanceDigest: string;
            category: import("./definition.js").FailureCaptureCategory;
            occurrences: number;
            taskFamilyId: string;
            taskFamilyDefinitionDigest: string;
            permissionDelta: {
                parent: readonly string[];
                candidate: readonly string[];
                added: readonly string[];
                removed: readonly string[];
                expandsAuthority: boolean;
            };
            rollbackTarget: {
                name: string;
                version: number;
                digest: string;
            };
            count: number;
            digest: string;
        };
        activationWatchId?: string;
        deploymentId?: string;
        activationComparisonId?: string;
        activatedVersion?: number;
        id: string;
        definition: {
            restoredFromVersion?: number;
            version?: number;
            parentVersion?: number | null;
            retired?: boolean;
            definitionDigest?: string;
            createdAt?: number;
            updatedAt?: number;
            preconditions: "current-owner-policy-and-fresh-goal";
            compensation: "stop-and-report";
            runExpansionCount?: number;
            runExpansionsDigest?: string;
            fileObservations?: import("./definition.js").SkillFileObservations;
            protocol: "assistant-skills/definition/v1";
            name: string;
            description: string;
            source: {
                digest: string;
                goalDefinitionDigest: string;
                stepCount: number;
                failedObservationCount: number;
                segmentCount: number;
            };
            inputs: readonly import("./definition.js").SkillInput[];
            steps: readonly import("./definition.js").SkillStep[];
        };
        definitionDigest: string;
        parentVersion: number;
        parentDigest: string | null;
        reason: string;
        trigger: string;
        expiresAt: number;
        state: "pending" | "activated" | "rejected";
        createdAt: number;
        updatedAt: number;
    }[];
    /** Re-read original Goals provenance before freezing an arm. This grants no execution authority. */
    inspectOwnerBenchmarkArm: (selection: BenchmarkArmSelection, signal?: AbortSignal) => Promise<BenchmarkArmSnapshot>;
    /** Host-only, single-use delegation to one exact live recipient service and frozen cell. */
    mintBenchmarkArm: (input: {
        selection: BenchmarkArmSelection;
        recipient: AssistantSkillsService;
        recipientScope: GoalScope;
        recipientOwnerRouteId: string;
        binding: SkillDelegatedArmBinding;
    }, signal?: AbortSignal) => Promise<BenchmarkArmCapability>;
    /** No definition is imported into the active/candidate tables; a restart cannot restore the authority. */
    mountBenchmarkArm: (capability: BenchmarkArmCapability, expected: SkillDelegatedArmBinding) => Promise<BenchmarkArmMount>;
    trial(exec: ToolRunContext, candidateId: string, goalId: string, inputs: Record<string, unknown>, invocationId: string): Promise<{
        skillName: string;
        version: number;
        invocationId: string;
        inputs: Record<string, unknown>;
        candidateId?: string;
        state: "awaiting-native-round";
        performed: boolean;
        context: string;
        next: string;
        goalId: string;
    } | {
        replayed: boolean;
        acceptance: string;
        id: string;
        invocationId: string;
        goalId: string;
        sessionId: string;
        skillName: string;
        version: number;
        inputs: Readonly<Record<string, unknown>>;
        state: import("./store.js").SkillRunState;
        steps: readonly SkillRunStep[];
        candidateId?: string;
        delegationDigest?: string;
        goalExecutionRunId?: string;
        goalDefinitionDigest?: string;
        nativeGoalId?: string;
        createdAt: number;
        updatedAt: number;
    }>;
    activate(agent: Agent | undefined, candidateId: string, trialRunId: string, observation?: {
        ownerRouteId: string;
        expiresAt: number;
        maxRuns: number;
        failureThreshold: number;
    }): {
        watch?: {
            taskFamilyDigest?: string;
            rollbackVersion?: number;
            id: 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";
            observedRuns: number;
            achieved: number;
            notAchieved: number;
            createdAt: number;
            updatedAt: number;
        };
        activated: {
            restoredFromVersion?: number;
            version?: number;
            parentVersion?: number | null;
            retired?: boolean;
            definitionDigest?: string;
            createdAt?: number;
            updatedAt?: number;
            preconditions: "current-owner-policy-and-fresh-goal";
            compensation: "stop-and-report";
            runExpansionCount?: number;
            runExpansionsDigest?: string;
            fileObservations?: import("./definition.js").SkillFileObservations;
            protocol: "assistant-skills/definition/v1";
            name: string;
            description: string;
            source: {
                digest: string;
                goalDefinitionDigest: string;
                stepCount: number;
                failedObservationCount: number;
                segmentCount: number;
            };
            inputs: readonly import("./definition.js").SkillInput[];
            steps: readonly import("./definition.js").SkillStep[];
        };
        activeVersion: number | null;
        replayed: boolean;
        improvement: string;
    };
    reject(agent: Agent | undefined, candidateId: string): {
        comparison: {
            kind: string;
            improvement: string;
            toolsAdded: string[];
            toolsRemoved: string[];
            inputsChanged: boolean;
            changedSteps: {
                index: number;
                before: string | null;
                after: string | null;
            }[];
        };
        failure?: {
            protocol: "assistant-skills/failure-capture-provenance/v1";
            provenanceDigest: string;
            category: import("./definition.js").FailureCaptureCategory;
            occurrences: number;
            taskFamilyId: string;
            taskFamilyDefinitionDigest: string;
            permissionDelta: {
                parent: readonly string[];
                candidate: readonly string[];
                added: readonly string[];
                removed: readonly string[];
                expandsAuthority: boolean;
            };
            rollbackTarget: {
                name: string;
                version: number;
                digest: string;
            };
            count: number;
            digest: string;
        };
        activationWatchId?: string;
        deploymentId?: string;
        activationComparisonId?: string;
        activatedVersion?: number;
        id: string;
        definition: {
            restoredFromVersion?: number;
            version?: number;
            parentVersion?: number | null;
            retired?: boolean;
            definitionDigest?: string;
            createdAt?: number;
            updatedAt?: number;
            preconditions: "current-owner-policy-and-fresh-goal";
            compensation: "stop-and-report";
            runExpansionCount?: number;
            runExpansionsDigest?: string;
            fileObservations?: import("./definition.js").SkillFileObservations;
            protocol: "assistant-skills/definition/v1";
            name: string;
            description: string;
            source: {
                digest: string;
                goalDefinitionDigest: string;
                stepCount: number;
                failedObservationCount: number;
                segmentCount: number;
            };
            inputs: readonly import("./definition.js").SkillInput[];
            steps: readonly import("./definition.js").SkillStep[];
        };
        definitionDigest: string;
        parentVersion: number;
        parentDigest: string | null;
        reason: string;
        trigger: string;
        expiresAt: number;
        state: "pending" | "activated" | "rejected";
        createdAt: number;
        updatedAt: number;
    };
    rollback(agent: Agent | undefined, name: string, expectedVersion: number, targetVersion: number): StoredSkillDefinition;
    /** Process-local capability check used by Goals; no tool can mint these assertions. */
    ownsOwnerAuthorizedRepair: (input: OwnerAuthorizedRepairInput, callback: () => void) => boolean;
    ownsOwnerAuthorizedRepairResume: (input: OwnerAuthorizedRepairResumeInput, callback: () => void) => boolean;
    armRepair: (agent: Agent | undefined, input: {
        goalId: string;
        sessionId?: string;
        profileId: string;
        ownerRouteId: string;
        invocationId: string;
        expiresAt: number;
        notify?: boolean;
    }) => {
        updatedAt: number;
        failure?: {};
        deploymentId?: {};
        candidateId?: {};
        repair?: {};
        id: string;
        state: import("./store.js").SkillRepairState;
        iteration: number;
        maxIterations: number;
        expiresAt: number;
        profileId: string;
        skillName: string;
        sourceGoalId: string;
    };
    repairStatus: (agent: Agent | undefined, id?: string) => {
        updatedAt: number;
        failure?: {};
        deploymentId?: {};
        candidateId?: {};
        repair?: {};
        id: string;
        state: import("./store.js").SkillRepairState;
        iteration: number;
        maxIterations: number;
        expiresAt: number;
        profileId: string;
        skillName: string;
        sourceGoalId: string;
    } | {
        profiles: {
            id: string;
            skillName: string;
            taskFamilyId: string;
            maxIterations: number;
            maxGoalRounds: number;
            maxModelCalls: number;
            maxToolCalls: number;
            maxDurationMs: number;
        }[];
        continuations: {
            updatedAt: number;
            failure?: {};
            deploymentId?: {};
            candidateId?: {};
            repair?: {};
            id: string;
            state: import("./store.js").SkillRepairState;
            iteration: number;
            maxIterations: number;
            expiresAt: number;
            profileId: string;
            skillName: string;
            sourceGoalId: string;
        }[];
    } | null;
    revokeRepair: (agent: Agent | undefined, id: string) => Promise<{
        updatedAt: number;
        failure?: {};
        deploymentId?: {};
        candidateId?: {};
        repair?: {};
        id: string;
        state: import("./store.js").SkillRepairState;
        iteration: number;
        maxIterations: number;
        expiresAt: number;
        profileId: string;
        skillName: string;
        sourceGoalId: string;
    }>;
    watch(agent: Agent | undefined, input: {
        ownerRouteId: string;
        skillName: string;
        version: number;
        fallbackVersion: number;
        expiresAt: number;
        maxRuns: number;
        failureThreshold: number;
    }): {
        taskFamilyDigest?: string;
        rollbackVersion?: number;
        id: 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";
        observedRuns: number;
        achieved: number;
        notAchieved: number;
        createdAt: number;
        updatedAt: number;
    };
    capture(agent: Agent | undefined, input: {
        ownerRouteId: string;
        goalId: string;
        name: string;
        description: string;
        parentVersion: number;
        expiresAt: number;
    }): {
        candidateId?: string;
        id: string;
        name: string;
        parentVersion: number;
        expiresAt: number;
        state: "pending" | "unknown" | "expired" | "revoked" | "captured" | "unsupported";
    };
    run(exec: ToolRunContext, goalId: string, name: string, version: number, inputs: Record<string, unknown>, invocationId: string): Promise<{
        skillName: string;
        version: number;
        invocationId: string;
        inputs: Record<string, unknown>;
        candidateId?: string;
        state: "awaiting-native-round";
        performed: boolean;
        context: string;
        next: string;
        goalId: string;
    } | {
        replayed: boolean;
        acceptance: string;
        id: string;
        invocationId: string;
        goalId: string;
        sessionId: string;
        skillName: string;
        version: number;
        inputs: Readonly<Record<string, unknown>>;
        state: import("./store.js").SkillRunState;
        steps: readonly SkillRunStep[];
        candidateId?: string;
        delegationDigest?: string;
        goalExecutionRunId?: string;
        goalDefinitionDigest?: string;
        nativeGoalId?: string;
        createdAt: number;
        updatedAt: number;
    }>;
}
//# sourceMappingURL=service.d.ts.map