forkit-connect 0.1.0

package/dist/v1/service.d.ts

@@ -0,0 +1,680 @@
+import { type ObservedAgentToolCallInput, type ObservedAgentToolCallResult, type ObservedAgentToolName } from './agent-observation';
+import { type SecureCredentialBackend } from './credential-store';
+import { type AgentProcessMetadata, type ProcessListEntry } from './process-scout';
+import { LocalStateStore } from './state';
+import { type VitalityPulseDependencies } from './vitality-pulse';
+import { type MonitorPassResult } from './lifecycle-monitor';
+import type { AgentLink, AgentModelUsageLedgerSummary, AgentReviewSnapshot, AgentType, BuildDatasetRef, BuildSession, BuildSessionStatus, C2SessionControlSource, C2SessionMode, C2SessionState, C2SessionSummary, C2LifecycleEvent, C2LiteEventType, ConnectBindingState, ConnectHandoffPayload, ConnectIdentityState, ConnectPermissionsSummary, ConnectServicesSummary, ConnectState, ConnectConfig, ConnectEffectiveBindingState, ServiceEntitlements, DaemonScanSummary, DaemonStatus, DetectedAgent, DetectedModel, DeliveredNotification, EvolutionReviewSnapshot, ModelEvolutionCandidate, DiscoveryClassification, DiscoveryMode, ModelBinding, ProviderHealthStatus, NotificationCandidate, NotificationSuggestedAction, RuntimePassportStatus, RuntimeType, SmartRegistrationInbox, SmartRegistrationInboxAction, PulseStatus, ReviewSnapshot, SanitizedProcessMetadata, ShadowFinding, TrayMenuModel, TrayStatusColor, TrainingLifecycleEventType, VitalityPulseEvent, VitalityPulseSummary, PendingReview } from './types';
+export type NotificationSender = (title: string, message: string, candidate?: NotificationCandidate) => boolean;
+export interface StatusResult {
+    runtimeId: string;
+    authenticated: boolean;
+    sessionIndicator: 'missing' | 'jwt-like' | 'opaque';
+    workspaceId: string | null;
+    projectId: string | null;
+    discoveryMode: DiscoveryMode;
+    daemonRunning: boolean;
+    daemonPid: number | null;
+    lastDaemonScanAt: string | null;
+    lastPulseAt: string | null;
+    detectedRuntimes: number;
+    detectedModels: number;
+    modelBindings: number;
+    queueDepth: number;
+    stateFile: string;
+    backendBaseUrl: string;
+}
+export interface DoctorCheck {
+    name: string;
+    status: 'PASS' | 'FAIL' | 'WARN';
+    details: string;
+}
+export interface RuntimeScanSummary {
+    runtime: string;
+    endpoint: string;
+    ok: boolean;
+    modelsFound: number;
+    error: string | null;
+}
+export interface ScanRuntimeResult {
+    ok: boolean;
+    models: DetectedModel[];
+    message: string;
+    runtimes: RuntimeScanSummary[];
+    discoveryMode: DiscoveryMode;
+    newModels: number;
+    alreadyKnownModels: number;
+    duplicateDiscoveriesSkipped: number;
+    findings: ShadowFinding[];
+    summary: DaemonScanSummary;
+}
+export interface DiscoveryCycleResult extends ScanRuntimeResult {
+    queue: QueueDraftSummary;
+    sync: {
+        processed: number;
+        succeeded: number;
+        failed: number;
+    };
+}
+export interface QueueDraftSummary {
+    queued: number;
+    skippedPending: number;
+    skippedBound: number;
+    skippedIgnored: number;
+    skippedDuplicate: number;
+}
+export interface ConnectActionScope {
+    bindingId: string | null;
+    connectDeviceId: string | null;
+    workspaceId: string;
+    projectId: string;
+    authoritative: boolean;
+}
+export interface ConnectBindingScopeSelectionResult {
+    workspaceId: string | null;
+    projectId: string | null;
+    bindingId: string | null;
+    bindingState: ConnectBindingState | null;
+    scopeSynced: boolean;
+    authoritative: boolean;
+    message: string;
+}
+export interface ConnectSelectionResult {
+    action: 'draft_created' | 'draft_queued' | 'passport_registered' | 'already_pending' | 'already_bound';
+    selector: string;
+    model: DetectedModel;
+    payload: Record<string, unknown> | null;
+    draftId: string | null;
+    gaid: string | null;
+    registrationKey: string;
+    bindingStatus: ModelBinding['status'];
+}
+export interface AgentWorkspaceObservationStatusResult {
+    agent: DetectedAgent;
+    observationEnabled: boolean;
+    observationSource: string | null;
+    workspaceRootHash: string | null;
+    workspaceId: string | null;
+    projectId: string | null;
+    observedToolCount: number;
+    blockedToolCount: number;
+    timedOutToolCount: number;
+    lastObservedTool: string | null;
+    lastObservedToolAt: string | null;
+    lastToolDecision: string | null;
+    allowed: boolean;
+    reviewRequired: boolean;
+    reasonCode: string;
+    message: string;
+    scope: ConnectActionScope | null;
+    privacySummary: string;
+}
+export interface AgentWorkspaceObservationEnableResult extends AgentWorkspaceObservationStatusResult {
+    enabledAt: string | null;
+}
+export interface C2StatusResult {
+    authenticated: boolean;
+    bound: boolean;
+    runtimeSignalKeyConfigured: boolean;
+    pendingEvents: number;
+    localOnlyEvents: number;
+    syncedEvents: number;
+    lastSyncAt: string | null;
+    lastSyncError: string | null;
+    boundGaid: string | null;
+}
+export interface C2SyncResult {
+    attempted: number;
+    succeeded: number;
+    failed: number;
+    pending: number;
+    synced: number;
+    lastSyncAt: string | null;
+    lastSyncError: string | null;
+}
+interface RemotePassportReconcileResult {
+    checked: boolean;
+    matched: number;
+    autoConnected: number;
+    status: 'not_authenticated' | 'synced' | 'unavailable';
+    error: string | null;
+}
+export interface TrainInitResult {
+    buildSession: BuildSession;
+    draftAction: 'draft_created' | 'draft_queued';
+    draftId: string | null;
+    gaid: string | null;
+    payload: Record<string, unknown>;
+}
+export interface BuildSessionStatusSummary {
+    build_session_id: string;
+    model_name: string;
+    framework: string;
+    task: string;
+    build_status: BuildSessionStatus;
+    draft_status: 'draft_created' | 'draft_queued' | 'bound' | 'local_only';
+    draft_id: string | null;
+    passport_gaid: string | null;
+    dataset_refs_count: number;
+    versions_count: number;
+    metrics_count: number;
+    latest_lifecycle_event: TrainingLifecycleEventType | null;
+    c2_sync_status: {
+        pending: number;
+        synced: number;
+        last_error: string | null;
+    } | null;
+    updated_at: string;
+}
+export interface AgentScanResult {
+    agents: DetectedAgent[];
+    newAgents: number;
+    knownAgents: number;
+    inactiveMarked: number;
+}
+export interface AgentStatusResult {
+    detectedAgents: number;
+    connectedAgents: number;
+    linkedAgents: number;
+    unlinkedAgents: number;
+    latestAgentLifecycleEvent: C2LiteEventType | null;
+    c2SyncStatus: {
+        pending: number;
+        synced: number;
+        lastError: string | null;
+    } | null;
+}
+export interface TrayStatusResult {
+    daemonRunning: boolean;
+    detectedModels: number;
+    detectedAgents: number;
+    shadowOrUnconnectedCount: number;
+    pulseStatus: PulseStatus;
+    c2PendingCount: number;
+    recommendedNextAction: NotificationSuggestedAction | null;
+    statusColor: TrayStatusColor;
+}
+export interface NotificationStatusResult {
+    enabled: boolean;
+    notification_min_interval_seconds: number;
+    delivered_count: number;
+    last_delivered_at: string | null;
+    recent_deliveries: DeliveredNotification[];
+}
+export interface NotificationDeliveryResult {
+    delivered: number;
+    suppressed: number;
+    fallback: boolean;
+    disabled: boolean;
+    notifications: NotificationCandidate[];
+}
+export interface ConnectInitResult {
+    identity: ConnectIdentityState;
+    entitlements: ServiceEntitlements;
+    permissions: ConnectPermissionsSummary;
+    privacy_summary: string;
+}
+export interface RuntimeReviewEntry {
+    runtime_gaid: string;
+    runtime_name: string;
+    runtime_type: string;
+    status: RuntimePassportStatus;
+    health_status: ProviderHealthStatus;
+    linked_models_count: number;
+    linked_agents_count: number;
+    source_endpoint_label: string;
+    recommended_action: string;
+}
+export interface RuntimeReviewSummary {
+    total_runtimes: number;
+    runtimes: RuntimeReviewEntry[];
+}
+export interface RuntimePassportStatusResult {
+    total_runtimes: number;
+    online_runtimes: number;
+    offline_runtimes: number;
+    linked_runtimes: number;
+    unlinked_runtimes: number;
+    unhealthy_runtimes: number;
+    latest_runtime_lifecycle_event: C2LiteEventType | null;
+    c2_pending_count: number;
+}
+export interface ConnectStatusOverview {
+    device_paired: boolean;
+    workspace_id: string | null;
+    project_id: string | null;
+    binding_state: ConnectBindingState | null;
+    lifecycle_note: string | null;
+    daemon_status: 'running' | 'stopped';
+    models_discovered: number;
+    agents_discovered: number;
+    runtimes_discovered: number;
+    paused_session_count: number;
+    revoked_session_count: number;
+    credential_reconnect_needed: boolean;
+    ready_to_connect_count: number;
+    needs_confirmation_count: number;
+    connected_count: number;
+    c2_sync_pending: number;
+    privacy_mode: 'metadata only';
+    next_recommended_action: SmartRegistrationInboxAction | null;
+}
+export declare class ConnectV1Service {
+    private readonly stateStore;
+    private readonly credentialStore;
+    constructor(stateDir?: string, options?: {
+        credentialBackend?: SecureCredentialBackend;
+        legacyCredentialBackend?: SecureCredentialBackend | null;
+    });
+    getStateStore(): LocalStateStore;
+    private getStoredSessionRef;
+    private getEnvironmentSessionRef;
+    private getActiveSessionRef;
+    private getSessionRefSource;
+    readSessionRef(): string | null;
+    private hasSessionRef;
+    private clearStoredRuntimeSignalSecrets;
+    private clearStoredSessionCredential;
+    private clearCredentialReconnectNeededSessions;
+    private getEffectiveBindingState;
+    getEffectiveBinding(): ConnectEffectiveBindingState | null;
+    private getBindingScope;
+    private getLocalWorkspaceProjectScope;
+    private getBindingActionConfig;
+    private buildLocalScopeActionStatus;
+    getBindingActionStatus(action: 'draft_creation' | 'evidence_sync' | 'runtime_session_sync' | 'lineage_suggestions', state?: ConnectState): {
+        allowed: boolean;
+        reviewRequired: boolean;
+        reasonCode: string;
+        message: string;
+        bindingState: ConnectBindingState | null;
+    };
+    private getAuthorizedBindingForAction;
+    private getAuthorizedScopeForAction;
+    getActionScope(action: 'draft_creation' | 'evidence_sync' | 'runtime_session_sync' | 'lineage_suggestions', state?: ConnectState): ConnectActionScope | null;
+    private canAttemptScopedBackendAction;
+    getBindingLifecycleNotice(state?: ConnectState): string | null;
+    private getBindingActionErrorCode;
+    private bindingRequiresReconnect;
+    private filterInboxActionsForBinding;
+    private resolveInboxActionForBinding;
+    buildDeviceConnectStartPayload(): {
+        connect_device_id: string | null;
+        connect_public_key: string | null;
+        device_label: string | null;
+        client_version: string | null;
+        platform: string | null;
+        arch: string | null;
+    };
+    private migrateLegacyCredentials;
+    private getIdentityState;
+    private hasStoredPrivateKey;
+    private getIdentityReadiness;
+    private buildServiceEntitlements;
+    private syncServiceEntitlements;
+    private syncIdentityFromLocalState;
+    private createConnectIdentity;
+    initializeConnectIdentity(): ConnectInitResult;
+    setSessionRef(sessionRef: string | null): void;
+    private mergeEffectiveBindingRecord;
+    private syncBindingScopeAndConsent;
+    refreshEffectiveBinding(options?: {
+        skipAutoScopeSync?: boolean;
+    }): Promise<ConnectEffectiveBindingState | null>;
+    setBindings(workspaceId: string | null, projectId: string | null): void;
+    private buildStandardBindingConsentProfile;
+    bindWorkspaceProject(workspaceId: string | null, projectId: string | null): Promise<ConnectBindingScopeSelectionResult>;
+    getStatus(): StatusResult;
+    getConfig(): ConnectConfig;
+    getServiceEntitlements(): ServiceEntitlements;
+    private getApiClient;
+    private ensureRuntimePassportIdentity;
+    private findRuntimePassportByGaid;
+    private findRuntimePassportForRuntime;
+    private findDetectedRuntimeForModel;
+    private createOrUpdateRuntimePassport;
+    private syncRuntimePassportAssociations;
+    private ensureRuntimePassportForModel;
+    private extractBackendErrorCode;
+    private isBindingSyncDriftCode;
+    private shouldHaltScopedSyncAfterFailure;
+    private reconcileScopedBackendFailure;
+    private findC2Session;
+    private buildSyntheticGovernorSessionId;
+    private queueC2SessionAcknowledgement;
+    private upsertObservedC2Session;
+    observeDeploymentSession(input: {
+        sessionId: string;
+        passportGaid: string;
+        runtimeGaid?: string | null;
+        modelName?: string | null;
+        agentId?: string | null;
+        workspaceId?: string | null;
+        projectId?: string | null;
+        sessionMode: C2SessionMode;
+        controlSource: C2SessionControlSource;
+        lastSeenAt?: string | null;
+        lastControlSeenAt?: string | null;
+        metadata?: Record<string, unknown>;
+    }): C2SessionState;
+    observeBackendCommunicationState(input: {
+        passportGaid: string | null;
+        runtimeGaid?: string | null;
+        modelName?: string | null;
+        agentId?: string | null;
+        sessionId?: string | null;
+        status: number;
+        body?: unknown;
+        source: 'heartbeat' | 'runtimeSignal' | 'draft_sync' | 'deployments';
+    }): C2SessionState | null;
+    observeTransientRuntimeSyncFailure(input: {
+        passportGaid: string | null;
+        runtimeGaid?: string | null;
+        modelName?: string | null;
+        agentId?: string | null;
+        sessionId?: string | null;
+        source: 'heartbeat' | 'runtimeSignal' | 'draft_sync' | 'deployments';
+        reason?: string | null;
+        status?: number | null;
+        details?: unknown;
+    }): C2SessionState | null;
+    getC2SessionSummary(): C2SessionSummary;
+    syncC2SessionsFromBackend(options?: {
+        suppressErrors?: boolean;
+    }): Promise<C2SessionSummary>;
+    private buildInboxItemId;
+    private isDeferredReviewActive;
+    private getModelReviewDisposition;
+    private getRuntimeReviewDisposition;
+    private buildModelVerificationSummary;
+    private buildRuntimeVerificationSummary;
+    private findConnectableModelForRuntime;
+    private clearModelReviewDeferral;
+    private buildPassportMatchSuggestionForModel;
+    private normalizeRemotePassportList;
+    private loadRemoteWorkspaceNameMaps;
+    private remotePassportMetadataValue;
+    private scoreRemotePassportForModel;
+    private findRemotePassportMatchForModel;
+    private autoConnectRemotePassportModel;
+    reconcileOwnedPassportsFromForkit(): Promise<RemotePassportReconcileResult>;
+    private autoConnectMatchedModel;
+    private findAgentModelCandidate;
+    private getDefaultRuntimeSignalApiKey;
+    private findBindingByGaid;
+    private getPrimaryBoundBinding;
+    private setRuntimeSignalApiKeyForGaid;
+    private resolveRuntimeSignalApiKeyForEvent;
+    /**
+     * Promote local-only events (no passport_gaid) by assigning the given gaid.
+     * Safe to call after a model is bound: events were observed on this device
+     * for the same model, we just didn't know the gaid at record time.
+     */
+    private backfillLocalOnlyC2Events;
+    /**
+     * If a runtime signal API key is available in the environment and a bound
+     * GAID exists but no key is stored yet, persist the key automatically.
+     * Triggers a GAID backfill on local-only events to make them syncable.
+     * Returns true if a new key was stored.
+     */
+    autoConfigureRuntimeSignalKeyFromEnv(): boolean;
+    /**
+     * Explicitly configure a runtime signal API key for a GAID and promote all
+     * pre-binding local-only events to syncable by backfilling the GAID.
+     * Validates key format: 8–512 printable ASCII characters.
+     */
+    configureRuntimeSignalKey(options: {
+        gaid: string;
+        apiKey: string;
+    }): {
+        stored: boolean;
+        backfilled: number;
+        gaid: string;
+        keyRef: string | null;
+    };
+    /**
+     * After login, automatically create a runtime-signal API key for every bound
+     * passport that doesn't already have one stored locally.
+     *
+     * This is what makes "login once → everything works" possible.
+     * The user never needs to run `c2 set-key` manually.
+     */
+    autoProvisionRuntimeSignalKeys(options?: {
+        suppressErrors?: boolean;
+    }): Promise<{
+        provisioned: string[];
+        skipped: string[];
+        failed: string[];
+    }>;
+    /**
+     * Run one pass of the deep lifecycle monitoring engine.
+     * Called every daemon scan cycle automatically — no configuration needed.
+     */
+    runLifecycleMonitoringPass(): MonitorPassResult;
+    /**
+     * Return all pending human-review items (or all reviews regardless of status).
+     */
+    getPendingReviews(options?: {
+        all?: boolean;
+    }): PendingReview[];
+    /**
+     * Human confirms or dismisses a review item.
+     * If `auto_confirm_after_first` is set on the review, future detections of
+     * the same kind for the same subject will be auto-confirmed.
+     */
+    resolveReview(reviewId: string, decision: 'confirmed' | 'dismissed'): {
+        resolved: boolean;
+        message: string;
+    };
+    private buildC2LifecycleEvent;
+    private recordC2LifecycleEvents;
+    private getC2EventSyncSummary;
+    recordC2LifecycleEvent(input: {
+        eventType: C2LiteEventType;
+        occurredAt?: string;
+        runtimeGaid?: string | null;
+        runtimeName?: string | null;
+        runtimeType?: RuntimeType | null;
+        modelName?: string | null;
+        discoveryHash?: string | null;
+        registrationKey?: string | null;
+        passportGaid?: string | null;
+        workspaceId?: string | null;
+        projectId?: string | null;
+        pulseStatus?: PulseStatus | null;
+        connectionClassification?: DiscoveryClassification | null;
+        daemonRunning?: boolean | null;
+        shadowCandidateReason?: string | null;
+        metadata?: Record<string, unknown>;
+    }): C2LifecycleEvent;
+    getC2Status(): C2StatusResult;
+    private findAgentByIdOrName;
+    private findAgentLink;
+    private findLinkedModelForAgent;
+    private closeActiveAgentModelUsage;
+    private recordAgentModelUsageObservation;
+    private refreshAgentModelUsageFromLinks;
+    private buildObservedAgentCandidate;
+    private buildAgentObservationStatus;
+    private updateAgentObservationMetadata;
+    private buildConnectSelfAgentCandidate;
+    private buildDetectedAgent;
+    private queueAgentC2Event;
+    private countC2ForAgent;
+    scanAgents(options?: {
+        processEntries?: ProcessListEntry[];
+        agentProcessResults?: AgentProcessMetadata[];
+        detectedAt?: string;
+        discoverySource?: 'process_scan' | 'daemon_scan';
+        includeConnectSelf?: boolean;
+    }): Promise<AgentScanResult>;
+    buildAgentReviewSnapshot(): AgentReviewSnapshot;
+    connectAgent(selector: string): DetectedAgent;
+    registerObservedAgent(input: {
+        agentName: string;
+        agentType: AgentType;
+        signature: string;
+        processName?: string | null;
+        executableName?: string | null;
+        matchedTerms?: string[];
+        commandHash?: string | null;
+        pathHash?: string | null;
+        metadata?: Record<string, unknown>;
+    }): Promise<DetectedAgent>;
+    enableAgentWorkspaceObservation(selector: string, input: {
+        workspaceRoot: string;
+        source: 'vscode_extension' | 'mcp_server' | 'coding_agent';
+        allowedTools?: ObservedAgentToolName[];
+    }): AgentWorkspaceObservationEnableResult;
+    disableAgentWorkspaceObservation(selector: string, input?: {
+        source?: 'vscode_extension' | 'mcp_server' | 'coding_agent';
+        reason?: string;
+    }): AgentWorkspaceObservationStatusResult;
+    getAgentWorkspaceObservationStatus(selector: string): AgentWorkspaceObservationStatusResult;
+    runObservedAgentTool(selector: string, input: Omit<ObservedAgentToolCallInput, 'workspaceRoot'> & {
+        workspaceRoot: string;
+    }): Promise<ObservedAgentToolCallResult>;
+    private buildAgentDraftPayload;
+    connectAgentPassport(selector: string): Promise<DetectedAgent>;
+    linkAgentToModel(selector: string, modelSelector: string): AgentLink;
+    getAgentStatus(): AgentStatusResult;
+    getAgentModelUsageLedger(selector?: string): AgentModelUsageLedgerSummary;
+    buildSmartRegistrationInbox(): SmartRegistrationInbox;
+    getConnectStatusOverview(): ConnectStatusOverview;
+    private resolveRecommendedNextAction;
+    getTrayStatus(): TrayStatusResult;
+    private getInboxDetailText;
+    private getInboxDetailBoolean;
+    private resolveScopeSuggestion;
+    private maybeRecordScopeMismatchEvidence;
+    private getNotificationScopeSummaryFromInbox;
+    private getNotificationScopeSummary;
+    private getNotificationRuntimeLabel;
+    private getNotificationSourceSummary;
+    getNotificationCandidates(): NotificationCandidate[];
+    private getNotificationTargetId;
+    private wasNotificationRecentlyDelivered;
+    private markNotificationDelivered;
+    getNotificationStatus(limit?: number): NotificationStatusResult;
+    deliverPendingNotifications(options?: {
+        candidates?: NotificationCandidate[];
+        force?: boolean;
+        notificationSender?: NotificationSender;
+        recordDelivery?: boolean;
+        deliveredAt?: string;
+    }): NotificationDeliveryResult;
+    sendTestNotification(options?: {
+        notificationSender?: NotificationSender;
+    }): NotificationDeliveryResult;
+    buildTrayMenuModel(): TrayMenuModel;
+    getConnectPermissions(): ConnectPermissionsSummary;
+    getConnectServices(): ConnectServicesSummary;
+    private buildEvolutionSnapshot;
+    private buildFallbackEvolutionBaseline;
+    private ensureEvolutionBaselineForBinding;
+    private findLatestBuildSessionForEvolution;
+    private deriveEvolutionChangeTypes;
+    private buildEvolutionCandidateEventFingerprint;
+    private recordEvolutionCandidate;
+    syncEvolutionCandidates(): ModelEvolutionCandidate[];
+    reviewModelEvolution(): EvolutionReviewSnapshot;
+    private buildSignedEvent;
+    buildConnectHandoff(): ConnectHandoffPayload;
+    private buildTrainingLifecycleEvent;
+    private findBuildSession;
+    private requireBuildSession;
+    private buildTrainingDraftPayload;
+    private queueTrainingC2Event;
+    private countC2ForBuildSession;
+    private buildBuildSessionSummary;
+    private saveBuildSession;
+    private shouldFallbackToQueuedTrainingDraft;
+    initTrainingBuildSession(input: {
+        modelName: string;
+        framework: string;
+        task: string;
+        datasetRef?: string | null;
+    }): Promise<TrainInitResult>;
+    recordTrainingLifecycleEvent(buildSessionId: string, eventType: Exclude<TrainingLifecycleEventType, 'training_initialized'>, metadata?: Record<string, unknown>): BuildSession;
+    recordTrainingDatasetChange(buildSessionId: string, datasetRef: string, changeType: BuildDatasetRef['change_type']): BuildSession;
+    recordTrainingMetric(buildSessionId: string, metricName: string, metricValue: number): BuildSession;
+    recordTrainingVersion(buildSessionId: string, versionName: string, reason: string): BuildSession;
+    recordTrainingArtifact(buildSessionId: string, artifactPath: string, hashArtifact: boolean): BuildSession;
+    getTrainingStatus(buildSessionId?: string): BuildSessionStatusSummary | BuildSessionStatusSummary[];
+    markBuildSessionDraftPublished(draftId: string, passportGaid: string | null, workspaceId: string | null, projectId: string | null): BuildSession | null;
+    private buildC2RuntimeSignalPayload;
+    private runtimeRecommendedAction;
+    getRuntimePassportReview(): RuntimeReviewSummary;
+    getRuntimePassportStatus(): RuntimePassportStatusResult;
+    private buildRuntimeHandoffSummary;
+    flushC2LifecycleEvents(options?: {
+        runtimeSignalApiKey?: string | null;
+        gaid?: string | null;
+        suppressErrors?: boolean;
+    }): Promise<C2SyncResult>;
+    private buildC2ScanEvents;
+    private buildPulseTransitionEvents;
+    setDiscoveryMode(mode: DiscoveryMode): ConnectConfig;
+    setDaemonIntervalSeconds(seconds: number): ConnectConfig;
+    setNotificationsEnabled(enabled: boolean): ConnectConfig;
+    setNotificationMinIntervalSeconds(seconds: number): ConnectConfig;
+    setEvolutionBridgeEnabled(enabled: boolean): ConnectConfig;
+    private isProcessAlive;
+    getDaemonStatus(): DaemonStatus;
+    markDaemonStarted(pid: number): DaemonStatus;
+    markDaemonStopped(lastError: string | null): DaemonStatus;
+    recordDaemonScan(summary: DaemonScanSummary): DaemonStatus;
+    recordDaemonError(lastError: string): DaemonStatus;
+    getPulseSummary(): VitalityPulseSummary | null;
+    getPulseHistory(limit?: number): VitalityPulseEvent[];
+    recordPulseSummary(summary: VitalityPulseSummary): VitalityPulseSummary;
+    recordPulseError(lastError: string): string;
+    runVitalityPulseCycle(dependencies?: VitalityPulseDependencies): Promise<VitalityPulseSummary>;
+    private findBindingForModel;
+    private findPendingQueueItem;
+    private countDetectionEvents;
+    private parseDraftResponse;
+    private withDraftBindingPayload;
+    private withRuntimeBindingPayload;
+    private buildConnectDraftPayload;
+    private resolveModelSelection;
+    private buildModelReviewEntry;
+    buildReviewSnapshot(summary?: DaemonScanSummary, options?: {
+        recordEvent?: boolean;
+    }): ReviewSnapshot;
+    connectDetectedModel(selector: string, options?: {
+        visibility?: 'private' | 'public';
+        destination?: 'draft' | 'passport';
+    }): Promise<ConnectSelectionResult>;
+    private resolveRuntimePassportSelection;
+    connectRuntimeSuggestion(selector: string): Promise<ConnectSelectionResult>;
+    private buildModelFindings;
+    private buildProviderFindings;
+    private buildProcessFindings;
+    private buildDaemonSummary;
+    scanRuntime(options?: {
+        processScoutResults?: SanitizedProcessMetadata[];
+        includeProcessScout?: boolean;
+    }): Promise<ScanRuntimeResult>;
+    runDiscoveryCycle(options?: {
+        processScoutResults?: SanitizedProcessMetadata[];
+    }): Promise<DiscoveryCycleResult>;
+    queueModelDraftsFromDetected(): QueueDraftSummary;
+    processQueue(): Promise<{
+        processed: number;
+        succeeded: number;
+        failed: number;
+    }>;
+    queueHeartbeatRuntimeSignal(gaid: string | null, apiKey: string | null): string | null;
+    queueConfiguredHeartbeatRuntimeSignal(gaid: string | null): string | null;
+    runDoctorChecks(): Promise<DoctorCheck[]>;
+    markModelIgnored(modelName: string, digest: string): boolean;
+    deferDetectedModel(selector: string, deferHours?: number): boolean;
+    markRuntimeIgnored(selector: string): boolean;
+    deferRuntimeSuggestion(selector: string, deferHours?: number): boolean;
+    notImplemented(feature: string): never;
+    ensureNoProductionPolicyBypass(): void;
+    createEvidenceId(): string;
+}
+export {};
+//# sourceMappingURL=service.d.ts.map