import { Context, Service } from '@deepseek-ai/cordis';
import type { Agent } from '@deepseek-ai/dsh-agent';
import type { ToolDefinition, ToolExecution } from '@deepseek-ai/dsh-tools';
import Schema from '@deepseek-ai/schemastery';
import { type RestartRecord } from './restart-store.js';
import { type RestartConfig } from './restart-runtime.js';
import { type ApprovalDispatchRouteV2, type AssistantPolicyService } from '@dsh-enhanced/assistant-policy';
import type { TrustedTaskLearningProjectionReceipt, TrustedDeliveryEvaluationRegistration } from '@dsh-enhanced/assistant-evaluation';
import { type GrowthWorkflowTraceSourceRegistration, type ResolvedWorkflowAutomationTemplate, type WorkflowAutomationTemplate, type WorkflowScope, type WorkflowTraceSink } from '@dsh-enhanced/assistant-growth-contract';
import { type InboundMessageProcessor } from './coordinator.js';
import { DeliveryStore, type CommitOwnerAnchoredWorkflowTraceResult } from './store.js';
import type { OwnerApprovalStatusRead } from './approval-status-context.js';
import { type NativeWebOwnerConfig, type NativeWebOwnerAccess } from './native-web-owner.js';
import { type DeliveryGoalWakeInput, type DeliveryGoalWakeResult } from './goal-wake-types.js';
import type { AcceptanceContract, TaskAcceptanceRegistration } from './acceptance.js';
import { type ForegroundTaskObservationRegistration, type ForegroundToolCallAttestation } from './foreground-observation.js';
import { type ReplyReplayBlockConfig, type ReplyReplayBlockHandle } from './reply-replay.js';
import type { ConversationBinding, DeliveryAdapter, DeadLetterResolutionResult, DeliveryPreferenceRegistration, DeliveryPreferenceProducer, DeliveryPreferencePrincipalAttestation, DeliveryPreferenceTurnAttestation, ExternalPrincipalKey, InboundEnvelope, InboxRecord, ModelPickerIntent, ModelPickerState, ModelRouteRef, ModelSelectionResult, ModelSelectionSettlementInput, ModelSelectionTerminalResult, OwnerRouteAuthority, OwnerForegroundTaskSourceScope, OwnerForegroundTaskSource, OwnerForegroundTaskSourceCursor, OwnerForegroundTaskSourcePage, OwnerForegroundTaskSourceContent, OwnerForegroundTaskSourceRef, OwnerApprovalForPreferenceInput, OwnerApprovalForPreferenceResult, OwnerRouteValidationReceipt, OutboxRecord, PairingChallenge, PermissionPickerIntent, ResolvedOwnerRoute, StoredDeliveryPresentation, TrustedDeliveryPresentationRegistration } from './types.js';
/** A wake finalizes an already-flushed native Web reply, or creates one external outbox intent. */
export type DeliveryGoalWakeResultPublication = OutboxRecord | Readonly<{
    kind: 'native-session';
    sessionId: string;
}>;
/**
 * Process-local authenticity against accidental service-slot collisions. The
 * private symbol is never exported, so copying the public method shape is not
 * enough to solicit a genuine registration. This is not an OS/process sandbox
 * boundary against code already executing inside the trusted Host process.
 */
export declare function isTrustedDeliveryPreferenceProducer(value: unknown): value is DeliveryPreferenceProducer;
/** Owner-bound discovery evidence, not permission to execute or adopt a repair. */
export interface OwnerForegroundLearningTask {
    readonly protocol: 'assistant-delivery/owner-foreground-learning/v1';
    /** Current owner authority with the original task's immutable execution binding. */
    readonly owner: Readonly<OwnerRouteValidationReceipt>;
    readonly canonical: TrustedTaskLearningProjectionReceipt;
    readonly judgement: 'independent-verifier' | 'owner-feedback' | 'unresolved';
    readonly ownerRevision?: Readonly<{
        version: number;
        action: 'initial' | 'correct' | 'withdraw';
    }>;
    readonly feedback?: Readonly<{
        inboxId: string;
        text: string;
        truncated: boolean;
    }>;
    readonly source: Readonly<{
        sessionId: string;
        inboxId: string;
        objective: string;
        truncated: boolean;
        quiescent: boolean;
        modelSelectionState: 'missing' | 'frozen' | 'inconsistent';
        modelSelection?: Readonly<{
            provider: string;
            model: string;
            reasoningEffort?: string;
        }>;
        reply?: Readonly<Pick<OwnerForegroundTaskSourceContent['reply'], 'outboxId' | 'intentDigest' | 'fullTextDigest'> & {
            text: string;
            truncated: boolean;
            redacted: boolean;
        }>;
    }>;
}
export interface Config {
    databasePath: string;
    spoolPath: string;
    /** Explicit owner-scoped, finite same-code maintenance authority. Disabled when absent. */
    restart?: RestartConfig;
    schedulerEnabled?: boolean;
    tickIntervalMs?: number;
    /** Upper bound for one ordinary foreground task, including silent model/tool waits. */
    agentTaskTimeoutMs?: number;
    leaseMs?: number;
    maxAttempts?: number;
    maxConcurrency?: number;
    maxTextBytes?: number;
    retryBaseMs?: number;
    retryMaxMs?: number;
    pairingTtlMs?: number;
    pairingMaxAttempts?: number;
    defaultWorkspace?: string;
    defaultAgentPreset?: string;
    policyRef?: string;
    agentProvider?: string;
    agentModel?: string;
    agentMaxOutputTokens?: number;
    agentMaxAutoContinuationTurns?: number;
    /** Opt-in foreground wait for an armed native goal round driver. Zero disables it. */
    agentGoalContinuationTimeoutMs?: number;
    modelPickerTtlMs?: number;
    permissionPickerTtlMs?: number;
    toolApprovalTtlMs?: number;
    /** Bound durability preparation separately from the time given to the human. */
    toolApprovalPreparationTimeoutMs?: number;
    /** Host-owned stable routes. They are never exposed as Agent tools or prompt input. */
    ownerRoutes?: readonly OwnerRouteAuthority[];
}
export interface DeliveryInboundRuntime extends InboundMessageProcessor {
    canRequestRestart?(agent: Agent): boolean;
    requestRestart?(agent: Agent, reason: string): {
        id: string;
        status: string;
    };
    resumeRestart?(record: RestartRecord, binding: Readonly<ConversationBinding>, envelope: Readonly<InboundEnvelope>, signal: AbortSignal): Promise<unknown>;
    createSession(input: {
        envelope: Readonly<InboundEnvelope>;
        generation: number;
        previous?: Readonly<ConversationBinding>;
        signal: AbortSignal;
    }): Promise<{
        sessionId: string;
        workspace: string;
        agentPreset: string;
        policyRef: string;
    }>;
    /** Immediate, process-local control path; it must never wait behind the binding's Inbox lane. */
    cancelActive?(binding: Readonly<ConversationBinding>, cause: 'new' | 'stop'): boolean | Promise<boolean>;
}
export type AssistantDeliveryErrorCode = 'disposed' | 'missing-binding' | 'policy-denied' | 'runtime-conflict' | 'runtime-unavailable';
export declare class AssistantDeliveryError extends Error {
    readonly code: AssistantDeliveryErrorCode;
    constructor(code: AssistantDeliveryErrorCode, message: string);
}
/**
 * Structural mirrors of the Goals Host-only evidence shapes. Delivery must not
 * import `@dsh-enhanced/assistant-goals` types for this seam: goals' public
 * type surface re-exports Delivery types (its types.ts re-exports from
 * `@dsh-enhanced/assistant-delivery`), which pulls Delivery's own emitted
 * lib/*.d.ts back into its build program and fails emit (TS5055). The local
 * goal-wake-types.ts mirror sets the precedent. These are structural only:
 * the live Goals service is obtained through ctx.get and runtime-checked, and
 * Delivery re-fetches every trusted value itself.
 */
interface GoalScope {
    principalId: string;
    principalRecordId: string;
    principalVersion: number;
    workspace: string;
    preset: string;
}
/** Structural mirror of goals' OwnerGoalExecutionSnapshotInput (six keys). */
interface OwnerGoalExecutionSnapshotInput {
    ownerRouteId: string;
    principalId: string;
    workspace: string;
    preset: string;
    sessionId: string;
    goalId: string;
}
/**
 * Structural authority minted by the growth driver for one bounded wake.
 * Delivery never mints it: the object is only accepted after assertCurrent()
 * re-anchors the live owner route, and its scope must exactly match the
 * locator the driver asked to learn from.
 */
export interface OwnerAnchoredWorkflowAuthority {
    readonly id: string;
    readonly scope: Readonly<GoalScope>;
    readonly ownerRouteId: string;
    readonly expiresAt: number;
    assertCurrent(): void;
}
/** Result of one Host-only owner-anchored learning commit. */
export type CommitOwnerAnchoredWorkflowTraceServiceResult = CommitOwnerAnchoredWorkflowTraceResult;
declare module '@deepseek-ai/cordis' {
    interface Context {
        assistantDelivery: AssistantDeliveryService;
    }
}
interface ApprovalSettlementInput {
    operationId: string;
    callbackEventId: string;
    callbackChatId: string;
    bindingId: string;
    principal: ExternalPrincipalKey;
    proposalId: string;
    expectedVersion: number;
    diffHash: string;
    decision: 'approved' | 'rejected';
    reason: string;
}
export declare class AssistantDeliveryService extends Service {
    #private;
    static Config: Schema<Config>;
    private readonly deliveryStore;
    private readonly restartStore;
    private readonly restartInvocationId;
    private restartCodeDigest;
    private restartNoticeCursor;
    private restartFlight;
    private readonly restartController;
    private readonly restartSafeDefinitions;
    private readonly context;
    private readonly policy;
    private readonly registry;
    private readonly outbound;
    private readonly inbound;
    private readonly config;
    private readonly ownerRoutes;
    private readonly ownerRouteGuard;
    private nativeWebBound;
    private nativeWebOwner;
    private nativeWebRuntime;
    private readonly ownerId;
    private readonly bindingFlights;
    private readonly conversationTransitions;
    private readonly agentApprovalBindings;
    private readonly toolApprovalControllers;
    private readonly drainingUserQuestionAdapters;
    private readonly userQuestionAttempts;
    private readonly modelSelectionWaiters;
    private preferenceFeedbackSink;
    private evaluationSink;
    private workflowTraceSink;
    private automationPresentationBinding;
    private evolutionPresentationBinding;
    private readonly activePresentationRegistrations;
    private readonly evaluationProducerGeneration;
    private readonly preferenceProducerGeneration;
    private readonly acceptanceProducerGeneration;
    private acceptanceSink;
    private foregroundObserver;
    /** Once a live verifier required acceptance, loss of that verifier must not silently bypass it. */
    private acceptanceRequired;
    private readonly preferenceTurns;
    private readonly goalWakeResults;
    private modelSelectionFlight;
    private presentationFlight;
    private workflowTraceFlight;
    private naturalObjectiveFlight;
    private preferenceProjectionFlight;
    private inboundAdmissionRecoveryFlight;
    private inboundAdmissionRecoveryAfterSequence;
    private interruptedInboxNoticeFlight;
    private interruptedInboxNoticeAfterSequence;
    private readonly inboundAdmissionRecoveryController;
    private workflowTraceRetryTimer;
    private preferenceProjectionRetryTimer;
    private modelSelectionRetryTimer;
    private runtime;
    private timer;
    private active;
    constructor(ctx: Context, input: Config);
    issuePairing(operatorId: string, principal: ExternalPrincipalKey): {
        challenge: PairingChallenge;
        code: string;
    };
    confirmPairing(input: {
        challengeId: string;
        principal: ExternalPrincipalKey;
        code: string;
    }): import("./types.js").DeliveryPrincipal;
    linkPrincipal(input: {
        operatorId: string;
        owner: ExternalPrincipalKey;
        linked: ExternalPrincipalKey;
        expectedLinkedVersion: number;
    }): import("./types.js").DeliveryPrincipal;
    private validateApprovalSettlement;
    settleApproval(input: ApprovalSettlementInput): ReturnType<AssistantPolicyService['decideProposal']>;
    recoverApprovalSettlement(input: ApprovalSettlementInput): ReturnType<AssistantPolicyService['decideProposal']> | undefined;
    settleModelSelection(input: ModelSelectionSettlementInput): ModelSelectionResult;
    awaitModelSelection(input: ModelSelectionSettlementInput, signal: AbortSignal): Promise<ModelSelectionTerminalResult | undefined>;
    advanceModelPickerForCallback(input: {
        operationId: string;
        callbackChatId: string;
        cardMessageId: string;
        bindingId: string;
        principal: ExternalPrincipalKey;
        expected: ModelPickerState;
        next: ModelRouteRef;
    }): {
        applied: boolean;
        state: ModelPickerState;
    };
    getModelPickerForCallback(input: {
        operationId: string;
        callbackChatId: string;
        cardMessageId: string;
        bindingId: string;
        principal: ExternalPrincipalKey;
    }): ModelPickerIntent | undefined;
    settlePermissionSelection(input: {
        operationId: string;
        callbackEventId: string;
        callbackChatId: string;
        cardMessageId: string;
        bindingId: string;
        bindingVersion: number;
        sessionId: string;
        principal: ExternalPrincipalKey;
        issuedAt: number;
        expiresAt: number;
        expectedStateHash: string;
        emergencyStopVersion: number;
        targetLevel: 'ask' | 'auto' | 'full';
    }): Promise<{
        duplicate: boolean;
        inboxId: string;
        status: InboxRecord['status'];
    }>;
    resolveDeadLetter(input: {
        operatorId: string;
        kind: 'inbox' | 'outbox';
        id: string;
        expectedAttemptCount: number;
        resolution: 'cancel' | 'retry';
    }): DeadLetterResolutionResult<InboxRecord> | DeadLetterResolutionResult<OutboxRecord>;
    registerInboundRuntime(runtime: DeliveryInboundRuntime): () => void;
    /** Versioned capability: idle wake Agents remain alive through exact goal settlement. */
    goalWakeSettlementVersion: () => 1;
    goalWakeResultVersion: () => 1;
    /** Only the live Goals service can mint this process-local wake capability. */
    resumeScheduledGoal(input: DeliveryGoalWakeInput): Promise<DeliveryGoalWakeResult>;
    /** Finalize the captured native reply, or publish it only for a still-owned external channel. */
    enqueueScheduledGoalResult(input: DeliveryGoalWakeInput): DeliveryGoalWakeResultPublication;
    private publishScheduledGoalResult;
    /** A textless terminal Web wake may notify its original owner, never impersonate a reply. */
    private publishScheduledGoalCompletionNotice;
    private resolveScheduledGoalOutcome;
    /** Private verifier producer generation; invalidated with this service. */
    trustedAcceptanceProducerGeneration: () => string;
    registerTaskAcceptanceSink: (registration: TaskAcceptanceRegistration) => (() => void);
    inspectAcceptedExecution: (contract: AcceptanceContract) => Promise<import("./acceptance.js").AcceptedExecution | null>;
    private removeTaskAcceptanceSink;
    private beginForegroundTaskExecution;
    registerForegroundTaskObserver(registration: ForegroundTaskObservationRegistration): () => void;
    private observerCurrent;
    private observeForegroundBegin;
    private completeForegroundTaskExecution;
    private prepareForegroundTaskAcceptance;
    private completeForegroundTaskAcceptance;
    registerAdapter(adapter: DeliveryAdapter): Promise<() => Promise<void>>;
    private abortUserQuestionAttemptsForAdapter;
    private abortUserQuestionAttempts;
    private answerUserQuestion;
    private resolveUserQuestionRoute;
    private resolveUserQuestionRouteFromStore;
    /** Trusted Host configuration only; the returned capability fixes a pre-paired Web owner and scope. */
    bindNativeWebOwner: (ctx: Context, config: NativeWebOwnerConfig) => NativeWebOwnerAccess;
    /** Host-only proof of a single live native tool call in the exact claimed owner Inbox. */
    inspectOwnerForegroundToolCall(input: Readonly<{
        agent: Agent;
        authorityId: string;
        callId: string;
        toolName: string;
        argumentsJson: string;
    }>): Readonly<ForegroundToolCallAttestation> | undefined;
    /** Host-only, read-only source proof for an owner's live memory or wiki tool call. */
    inspectOwnerRequestedChange(execution: ToolExecution, input: {
        sourceId: string;
    }): Readonly<{
        route: ApprovalDispatchRouteV2;
        text: string;
        receiptDigest: string;
    }> | undefined;
    currentPreferenceTurn(agent: Agent): Readonly<DeliveryPreferenceTurnAttestation> | undefined;
    preferencePrincipalForAgent(agent: Agent): Readonly<DeliveryPreferencePrincipalAttestation> | undefined;
    private capturePreferenceTurn;
    trustedPreferenceProducerGeneration(): string;
    /** Exact process-local Preference owner registration; copied or self-asserted sinks fail. */
    registerTrustedPreferenceSink(registration: Readonly<DeliveryPreferenceRegistration>): () => void;
    trustedEvaluationProducerGeneration(): string;
    registerTrustedDeliveryEvaluationSink(registration: Readonly<TrustedDeliveryEvaluationRegistration>): () => void;
    /**
     * Register Growth's exact private sink. Replaying current is deliberately
     * queued after this method returns so a registration receipt can never be
     * confused with synchronous projection success.
     */
    registerWorkflowTraceSink(input: Readonly<{
        contractVersion: 1;
        sink: WorkflowTraceSink;
    }>): GrowthWorkflowTraceSourceRegistration;
    resolveWorkflowAutomationTemplate(input: Readonly<{
        contractVersion: 1;
        template: Readonly<WorkflowAutomationTemplate>;
        scope: Readonly<WorkflowScope>;
        ownerBindingId: string;
    }>): Readonly<ResolvedWorkflowAutomationTemplate>;
    /**
     * Host-only bridge from one exact reviewed workflow template to a v2 Policy
     * approval route. This method is not registered as an Agent tool.
     */
    prepareWorkflowApproval(input: Readonly<{
        sourceId: string;
        contractVersion: 1;
        template: Readonly<WorkflowAutomationTemplate>;
        scope: Readonly<WorkflowScope>;
        ownerBindingId: string;
    }>): ApprovalDispatchRouteV2;
    /**
     * Host-only owner-anchored workflow learning bridge. This method is not
     * registered as an Agent tool (same Host seam as prepareWorkflowApproval):
     * only the opt-in growth driver invokes it, and only with a locator plus one
     * bounded-wake authority. Delivery itself re-fetches both the verified Goals
     * source and the owner-run-trace proof, so the caller can never supply the
     * objective, steps, acceptance verdict or proof digest — a spoofed driver
     * learns nothing. A goal that does not honestly reduce to the single
     * no-tool `assistant.agent-turn` step is returned as `abstained` with zero
     * writes; the trace is projected through the existing outbox/drain chain.
     */
    commitOwnerAnchoredWorkflowTrace(input: Readonly<{
        locator: OwnerGoalExecutionSnapshotInput;
        authority: OwnerAnchoredWorkflowAuthority;
    }>): Promise<CommitOwnerAnchoredWorkflowTraceServiceResult>;
    /**
     * Host-only, content-free route minting seam for Preference promotion.
     * No binding id is accepted from the caller; Delivery resolves the unique
     * current binding from the exact owner lineage and generation.
     */
    prepareOwnerApprovalForPreference(input: Readonly<OwnerApprovalForPreferenceInput>): OwnerApprovalForPreferenceResult;
    health(): ReturnType<DeliveryStore['health']> & {
        adapters: number;
    };
    /** Exact process-local proof for a Delivery-minted publisher registration. */
    ownsTrustedDeliveryPresentationRegistration(registration: Readonly<TrustedDeliveryPresentationRegistration>): boolean;
    getDeliveryPresentation(presentationKey: string): StoredDeliveryPresentation | undefined;
    private presentationBinding;
    private setPresentationBinding;
    private presentationProducerGeneration;
    /**
     * Delivery owns the registration and its publish closure. The producer only
     * receives that closure after it has proven this exact in-process object is
     * its expected Delivery owner; replacement and disposal revoke it eagerly.
     */
    private bindPresentationProducer;
    private assertCurrentPresentationProducer;
    private publishTrustedDeliveryPresentation;
    private progressAuthorized;
    private isInboundAuthorized;
    private isPermissionController;
    private isOwnerFeedbackController;
    private ownerLineageForBinding;
    private authorizeOwnerPreferenceFeedback;
    private preferenceSignalAuthorizationKey;
    private dispatchPreferenceFeedback;
    private dispatchLearningCommand;
    private completedPreferenceEvents;
    private dispatchWorkflowCommand;
    /**
     * Convert only an authenticated reply to one exact Automation delivery into
     * a trusted objective label. The original run timestamp is retained because
     * Evolution re-proves the immutable production run; the later Inbox is a
     * separate evidence reference, never copied as prose.
     */
    private dispatchNaturalObjectiveFeedback;
    private drainNaturalObjectiveIntents;
    private runNaturalObjectiveIntents;
    private dispatchObjectiveFeedback;
    private dispatchGoalOutcomeFeedback;
    private authorizePermissionReply;
    /**
     * Provider event ids are scoped to an adapter account, while Outbox and the
     * Policy ledger share one database-wide idempotency namespace. Anchor every
     * command reply to the accepted Inbox row, whose id is stable across reopen.
     */
    private inboundReplyIdempotencyKey;
    private hasActivePrincipal;
    private toolApprovalRoute;
    private resolveToolApprovalAuthority;
    /** A source-thread notice, never raw command arguments or a new approval grant. */
    private notifyToolApproval;
    private requestToolApproval;
    acceptInbound(envelope: InboundEnvelope, recoverySignal?: AbortSignal): Promise<{
        duplicate: boolean;
        inboxId: string;
        status: InboxRecord['status'];
    }>;
    enqueueBackground(input: {
        sourceId: string;
        workspace: string;
        bindingId: string;
        idempotencyKey: string;
        text: string;
        format?: 'markdown' | 'plain';
        metadata?: Readonly<Record<string, string>>;
    }): OutboxRecord;
    private enqueueBackgroundAuthorized;
    /** Queue a typed owner notice. Accepted means queued; it never asserts user read. */
    enqueueOwnerNotification(input: {
        sourceId: string;
        ownerRouteId: string;
        scope: {
            principalId: string;
            principalRecordId: string;
            principalVersion: number;
            workspace: string;
            preset: string;
        };
        sessionId: string;
        idempotencyKey: string;
        text: string;
        expiresAt: number;
    }): OutboxRecord;
    /**
     * Dedicated Automation result lane. Every learning field is derived from an
     * authoritative Automations receipt; callers cannot supply metadata,
     * idempotency, source identity, occurrence, timestamp, or feedback text.
     */
    enqueueAutomationResult(input: {
        automationId: string;
        runId: string;
        workspace: string;
        bindingId: string;
        outputPreview: string;
    }): OutboxRecord;
    /** Resolve the current generation of one exact Host-owned owner route. */
    resolveOwnerRoute(authorityIdInput: string): ResolvedOwnerRoute;
    /**
     * Revalidate Recovery/other Host work against the live owner route without
     * exposing a session id, conversation id, user message or delivery content.
     */
    validateOwnerRoute(input: {
        authorityId: string;
        principalId: string;
        workspace: string;
        agentPreset: string;
    }): Readonly<OwnerRouteValidationReceipt>;
    /** Host-only proof that the live caller Agent belongs to the current owner route. */
    validateOwnerAgentForRoute(agent: Agent, authorityId: string): ReturnType<AssistantDeliveryService['validateOwnerRoute']> | undefined;
    /** Host-only durable ordinary-turn metadata; never registered as a model tool. */
    listOwnerForegroundTaskSources(input: OwnerForegroundTaskSourceScope & {
        after?: Readonly<OwnerForegroundTaskSourceCursor>;
        limit?: number;
    }): Readonly<OwnerForegroundTaskSourcePage>;
    /** Host-only exact terminal source metadata, including before reply Outbox exists. */
    inspectOwnerForegroundTaskSource(input: OwnerForegroundTaskSourceScope & {
        inboxId: string;
    }): Readonly<OwnerForegroundTaskSource> | undefined;
    /** Read one exact completed source under the current owner fence. */
    readOwnerForegroundTaskSource(input: OwnerForegroundTaskSourceScope & {
        inboxId: string;
        expectedSourceDigest: string;
        maxInputBytes?: number;
        maxReplyBytes?: number;
    }): Readonly<OwnerForegroundTaskSourceContent> | undefined;
    /** Hold Delivery's owner/source writer fence across synchronous downstream adoption. */
    withOwnerForegroundTaskSourceFence<T>(input: OwnerForegroundTaskSourceScope & {
        inboxId: string;
        expectedSourceDigest: string;
        maxInputBytes?: number;
        maxReplyBytes?: number;
    }, callback: (source: Readonly<OwnerForegroundTaskSourceContent>) => T): T;
    /** Hold one owner/source writer fence for a bounded, ordered batch of sources. */
    withOwnerForegroundTaskSourcesFence<T>(input: OwnerForegroundTaskSourceScope & {
        sources: readonly Readonly<OwnerForegroundTaskSourceRef>[];
    }, callback: (sources: readonly (Readonly<OwnerForegroundTaskSourceContent> | undefined)[]) => T): T;
    /** Host-only snapshot of the model selected for this owner's external conversation. */
    inspectOwnerModelSelection(input: {
        authorityId: string;
        principalId: string;
        workspace: string;
        agentPreset: string;
        sourceAgent?: Agent;
    }): Readonly<ModelRouteRef>;
    /**
     * Resolve one canonical foreground result against its actual owner lineage.
     * Evaluation's workspace/preset scope alone does not establish ownership.
     * Historical Sessions remain eligible after /new, but not after owner ABA.
     */
    inspectOwnerForegroundLearningTask(input: {
        authorityId: string;
        principalId: string;
        workspace: string;
        agentPreset: string;
        outcomeId: string;
    }): Readonly<OwnerForegroundLearningTask> | undefined;
    /**
     * Enqueue against a stable Host-owned route rather than a session binding.
     * Policy is evaluated against the exact `route:<authorityId>` resource. The
     * Store re-resolves under its write transaction, so a concurrent `/new`
     * either wins completely or follows the earlier immutable Outbox receipt.
     */
    enqueueBackgroundRoute(input: {
        sourceId: string;
        authorityId: string;
        idempotencyKey: string;
        text: string;
        format?: 'markdown' | 'plain';
    }): OutboxRecord;
    enqueueApproval(input: {
        route: Readonly<ApprovalDispatchRouteV2>;
        idempotencyKey: string;
        text: string;
        approval: NonNullable<import('./types.js').OutboundIntent['approval']>;
    }): OutboxRecord;
    private replyCommand;
    /**
     * Answers are authored as Markdown, but the coordinator drops an intent whose format the adapter
     * does not declare (`unsupported-format`). Ask for Markdown only where the channel renders it and
     * degrade to plain text elsewhere, so a reply is never lost to a capability mismatch.
     */
    private replyFormat;
    reply(agent: Agent | undefined, input: {
        idempotencyKey: string;
        text: string;
        format?: 'markdown' | 'model-picker' | 'permission-picker' | 'plain';
        modelPicker?: ModelPickerIntent;
        permissionPicker?: PermissionPickerIntent;
        replyToEventId?: string;
    }): OutboxRecord;
    /** Host-only replay boundary. The returned tombstone fences this exact Agent object permanently. */
    blockAgentRepliesForReplay(agent: Agent, config: ReplyReplayBlockConfig): ReplyReplayBlockHandle;
    private replyCompletedPreferenceTurn;
    private prepareAgentReply;
    history(agent: Agent | undefined, input: {
        limit?: number;
    }): {
        binding: ConversationBinding;
        inbox: InboxRecord[];
        outbox: OutboxRecord[];
    };
    bindAgentApprovalRoute(agent: Agent | undefined, input: {
        bindingId: string;
    }): () => void;
    prepareAgentApproval(agent: Agent | undefined, input: {
        sourceId: string;
    }): ApprovalDispatchRouteV2;
    /** Read only the current direct owner binding's exact Policy routes. */
    readOwnerApprovalStatus(agent: Agent | undefined): OwnerApprovalStatusRead | undefined;
    private restartCapabilityDigest;
    private restartAuthorized;
    /** Host-only maintenance gate shared by the native background scheduler. */
    isMaintenanceDraining(): boolean;
    private restartDispatchPermitted;
    /** Run only from native maintenance after the continuation notice is durably flushed. */
    private releaseRestartFenceOnAdmission;
    private otherRestartWorkQuiescent;
    canRequestRestart(agent: Agent | undefined): boolean;
    requestRestart(agent: Agent | undefined, reason: string): {
        id: string;
        status: string;
    };
    get supportsPlannedRestart(): boolean;
    /** Host-side registration of an exact, currently mounted read-only definition. */
    registerRestartSafeTool(caller: Context, definition: ToolDefinition): () => void;
    isRestartSafeTool(agent: Agent, name: string): boolean;
    /** Startup/tick reconciliation uses the existing native runtime, never requeues the old Inbox. */
    private drainRestartContinuations;
    private drainRestartFailureNotices;
    tick(): Promise<void>;
    whenIdle(): Promise<void>;
    start(): void;
    stop(): Promise<void>;
    private ensureBinding;
    private drainInboundAdmissions;
    private drainInterruptedInboxNotices;
    private runInterruptedInboxNotices;
    private runInboundAdmissionRecovery;
    private bindingForInbound;
    /**
     * Finish admissions that survived a process exit before their queue/rotate
     * commit. The provider need not retransmit them: any later message in the
     * same conversation first drives every older received row forward in its
     * original durable Inbox order. This includes ordinary messages that were
     * already persisted behind a blocked `/stop` or `/new` transition.
     */
    private recoverPendingInbound;
    private runConversationTransition;
    private rotateBinding;
    private stopInternal;
    private drainPreferenceProjections;
    private runPreferenceProjection;
    /** Host test/operator seam: project due trace revisions without waiting for the scheduler. */
    projectWorkflowTraces(): Promise<void>;
    private drainWorkflowTraces;
    private runWorkflowTraceProjection;
    private resolveModelSelectionWaiters;
    private cancelModelSelectionWaiters;
    private drainApprovalDispatches;
    private drainDeliveryPresentations;
    private runDeliveryPresentations;
    private drainModelSelectionSettlements;
    private runModelSelectionSettlements;
    private assertActive;
}
export declare const Config: Schema<Config>;
export {};
//# sourceMappingURL=service.d.ts.map