import { type CreateTaskOptions, type ListTasksOptions, type TaskRecord } from "../../boards/index.js";
import type { AgentCreationResult, AgentDeletionResult, AgentDescriptor, AgentInfo, AgentManagerUpdateResult, CreateAgentOptions, DeleteAgentOptions } from "../../domain/agent.js";
import type { InitializationResult } from "../../domain/opengoat-paths.js";
import { type Logger } from "../../logging/index.js";
import { type OrchestrationRunOptions, type OrchestrationRunResult, type RoutingDecision } from "../../orchestration/index.js";
import type { CommandRunResult, CommandRunnerPort } from "../../ports/command-runner.port.js";
import type { FileSystemPort } from "../../ports/file-system.port.js";
import type { PathPort } from "../../ports/path.port.js";
import type { OpenGoatPathsProvider } from "../../ports/paths-provider.port.js";
import type { AgentProviderBinding, OpenClawGatewayConfig, ProviderAuthOptions, ProviderExecutionResult, ProviderOnboardingSpec, ProviderRegistry, ProviderStoredConfig, ProviderSummary } from "../../providers/index.js";
import { type AgentLastAction, type SessionCompactionResult, type SessionHistoryResult, type SessionRemoveResult, type SessionRunInfo, type SessionSummary } from "../../sessions/index.js";
import { type InstallSkillRequest, type InstallSkillResult, type RemoveSkillRequest, type RemoveSkillResult, type ResolvedSkill } from "../../skills/index.js";
import { type TaskDelegationStrategiesConfig } from "./opengoat.service.helpers.js";
interface OpenGoatServiceDeps {
    fileSystem: FileSystemPort;
    pathPort: PathPort;
    pathsProvider: OpenGoatPathsProvider;
    nowIso?: () => string;
    providerRegistry?: ProviderRegistry;
    commandRunner?: CommandRunnerPort;
    logger?: Logger;
}
export interface RuntimeDefaultsSyncResult {
    ceoSyncCode?: number;
    ceoSynced: boolean;
    warnings: string[];
}
export interface DefaultAgentUpdateResult {
    defaultAgent: string;
    previousDefaultAgent: string;
    configPath: string;
}
export interface TaskCronDispatchResult {
    kind: "todo" | "doing" | "pending" | "blocked" | "inactive" | "topdown";
    targetAgentId: string;
    sessionRef: string;
    taskId?: string;
    subjectAgentId?: string;
    message?: string;
    ok: boolean;
    error?: string;
}
export interface TaskCronRunResult {
    ranAt: string;
    scannedTasks: number;
    todoTasks: number;
    doingTasks: number;
    blockedTasks: number;
    inactiveAgents: number;
    sent: number;
    failed: number;
    dispatches: TaskCronDispatchResult[];
}
export type InactiveAgentNotificationTarget = "all-managers" | "ceo-only";
export interface HardResetResult {
    homeDir: string;
    homeRemoved: boolean;
    deletedOpenClawAgents: string[];
    failedOpenClawAgents: Array<{
        agentId: string;
        reason: string;
    }>;
    removedOpenClawManagedSkillDirs: string[];
    warnings: string[];
}
export declare class OpenGoatService {
    private readonly fileSystem;
    private readonly pathPort;
    private readonly pathsProvider;
    private readonly agentService;
    private readonly agentManifestService;
    private readonly bootstrapService;
    private readonly providerService;
    private readonly skillService;
    private readonly sessionService;
    private readonly orchestrationService;
    private readonly boardService;
    private readonly commandRunner?;
    private readonly nowIso;
    private openClawManagedSkillsDirCache?;
    constructor(deps: OpenGoatServiceDeps);
    initialize(options?: {
        syncRuntimeDefaults?: boolean;
    }): Promise<InitializationResult>;
    getDefaultAgentId(options?: {
        requireExisting?: boolean;
    }): Promise<string>;
    setDefaultAgent(rawAgentId: string): Promise<DefaultAgentUpdateResult>;
    hardReset(): Promise<HardResetResult>;
    syncRuntimeDefaults(): Promise<RuntimeDefaultsSyncResult>;
    createAgent(rawName: string, options?: CreateAgentOptions): Promise<AgentCreationResult>;
    deleteAgent(rawAgentId: string, options?: DeleteAgentOptions): Promise<AgentDeletionResult>;
    setAgentManager(rawAgentId: string, rawReportsTo: string | null): Promise<AgentManagerUpdateResult>;
    listAgents(): Promise<AgentDescriptor[]>;
    listDirectReportees(rawAgentId: string): Promise<string[]>;
    listAllReportees(rawAgentId: string): Promise<string[]>;
    getAgentInfo(rawAgentId: string): Promise<AgentInfo>;
    listProviders(): Promise<ProviderSummary[]>;
    getProviderOnboarding(providerId: string): Promise<ProviderOnboardingSpec | undefined>;
    getProviderConfig(providerId: string): Promise<ProviderStoredConfig | null>;
    setProviderConfig(providerId: string, env: Record<string, string>): Promise<ProviderStoredConfig>;
    authenticateProvider(providerId: string, options?: ProviderAuthOptions): Promise<ProviderExecutionResult>;
    getAgentProvider(agentId: string): Promise<AgentProviderBinding>;
    setAgentProvider(agentId: string, providerId: string): Promise<AgentProviderBinding>;
    getOpenClawGatewayConfig(): Promise<OpenClawGatewayConfig>;
    setOpenClawGatewayConfig(config: OpenClawGatewayConfig): Promise<OpenClawGatewayConfig>;
    routeMessage(agentId: string, message: string): Promise<RoutingDecision>;
    runAgent(agentId: string, options: OrchestrationRunOptions): Promise<OrchestrationRunResult>;
    createTask(actorId: string, options: CreateTaskOptions): Promise<TaskRecord>;
    listTasks(options?: ListTasksOptions): Promise<TaskRecord[]>;
    listLatestTasks(options?: {
        assignee?: string;
        limit?: number;
    }): Promise<TaskRecord[]>;
    listLatestTasksPage(options?: {
        assignee?: string;
        owner?: string;
        status?: string;
        limit?: number;
        offset?: number;
    }): Promise<{
        tasks: TaskRecord[];
        total: number;
        limit: number;
        offset: number;
    }>;
    getTask(taskId: string): Promise<TaskRecord>;
    deleteTasks(actorId: string, taskIds: string[]): Promise<{
        deletedTaskIds: string[];
        deletedCount: number;
    }>;
    updateTaskStatus(actorId: string, taskId: string, status: string, reason?: string): Promise<TaskRecord>;
    addTaskBlocker(actorId: string, taskId: string, blocker: string): Promise<TaskRecord>;
    addTaskArtifact(actorId: string, taskId: string, content: string): Promise<TaskRecord>;
    addTaskWorklog(actorId: string, taskId: string, content: string): Promise<TaskRecord>;
    private assertManagerSupportsReportees;
    runTaskCronCycle(options?: {
        inactiveMinutes?: number;
        inProgressMinutes?: number;
        notificationTarget?: InactiveAgentNotificationTarget;
        notifyInactiveAgents?: boolean;
        delegationStrategies?: TaskDelegationStrategiesConfig;
        maxParallelFlows?: number;
    }): Promise<TaskCronRunResult>;
    private dispatchTopDownTaskDelegationAutomations;
    private dispatchTaskStatusAutomations;
    private dispatchInactiveAgentAutomations;
    listSkills(agentId?: string): Promise<ResolvedSkill[]>;
    listGlobalSkills(): Promise<ResolvedSkill[]>;
    installSkill(request: InstallSkillRequest): Promise<InstallSkillResult>;
    removeSkill(request: RemoveSkillRequest): Promise<RemoveSkillResult>;
    private resolveAgentSkillInstallOptions;
    runOpenClaw(args: string[], options?: {
        cwd?: string;
        env?: NodeJS.ProcessEnv;
    }): Promise<CommandRunResult>;
    listSessions(agentId?: string, options?: {
        activeMinutes?: number;
    }): Promise<SessionSummary[]>;
    prepareSession(agentId?: string, options?: {
        sessionRef?: string;
        forceNew?: boolean;
    }): Promise<SessionRunInfo>;
    getAgentLastAction(agentId?: string): Promise<AgentLastAction | null>;
    getSessionHistory(agentId?: string, options?: {
        sessionRef?: string;
        limit?: number;
        includeCompaction?: boolean;
    }): Promise<SessionHistoryResult>;
    resetSession(agentId?: string, sessionRef?: string): Promise<SessionRunInfo>;
    compactSession(agentId?: string, sessionRef?: string): Promise<SessionCompactionResult>;
    renameSession(agentId?: string, title?: string, sessionRef?: string): Promise<SessionSummary>;
    removeSession(agentId?: string, sessionRef?: string): Promise<SessionRemoveResult>;
    getHomeDir(): string;
    getPaths(): import("../../domain/opengoat-paths.js").OpenGoatPaths;
    private dispatchAutomationMessage;
    private resolveNowIso;
    private resolveInputAgentId;
    private resolveDefaultAgentId;
    private readGlobalConfig;
    private readJsonFileIfPresent;
    private initializeRuntimeDefaults;
    private resolveNowMs;
    private syncOpenClawRoleSkills;
    private removeOpenClawManagedRoleSkills;
    private ensureAgentProviderRoleSkills;
    private resolveOpenClawManagedSkillsDir;
    private listOpenClawAgents;
    private addWorkspaceAgentCandidates;
    private syncOpenClawAgentRegistration;
    private ensureOpenClawAgentLocation;
    private syncOpenClawAgentExecutionPolicies;
    private ensureOpenGoatPluginToolsRegistered;
    private resolveOpenGoatPluginSourcePath;
    private configureOpenClawPluginSourcePath;
    private mergePluginLoadPaths;
    private readPluginManifestId;
    private resolveOpenClawEnv;
    private collectInactiveAgents;
}
export {};