hivehq 2.0.0

package/dist/src/server/routes.d.ts

@@ -0,0 +1,6 @@
+import type { ConfigureAgentLaunchBody, CreateWorkerBody, CreateWorkspaceBody, ReportTaskBody, RouteDefinition, SendTaskBody, WorkerRole } from './route-types.js';
+export declare const matchRoute: (method: string, pathname: string) => {
+    handler: (context: import("./route-types.js").RouteContext) => Promise<void> | void;
+    params: Record<string, string>;
+} | null;
+export type { ConfigureAgentLaunchBody, CreateWorkerBody, CreateWorkspaceBody, ReportTaskBody, RouteDefinition, SendTaskBody, WorkerRole, };

package/dist/src/server/routes.js

@@ -0,0 +1,55 @@
+import { matchPath } from './route-helpers.js';
+import { dispatchRoutes } from './routes-dispatches.js';
+import { fsRoutes } from './routes-fs.js';
+import { marketplaceRoutes } from './routes-marketplace.js';
+import { openWorkspaceRoutes } from './routes-open-workspace.js';
+import { remoteRoutes } from './routes-remote.js';
+import { runtimeRoutes } from './routes-runtime.js';
+import { settingsRoutes } from './routes-settings.js';
+import { taskRoutes } from './routes-tasks.js';
+import { teamRoutes } from './routes-team.js';
+import { teamMemoryRoutes } from './routes-team-memory.js';
+import { teamRecallRoutes } from './routes-team-recall.js';
+import { uiRoutes } from './routes-ui.js';
+import { versionRoutes } from './routes-version.js';
+import { workflowScheduleRoutes } from './routes-workflow-schedules.js';
+import { workflowRoutes } from './routes-workflows.js';
+import { workspaceMemoryRoutes } from './routes-workspace-memory.js';
+import { workspaceMemoryDreamRoutes } from './routes-workspace-memory-dreams.js';
+import { workspaceRoutes } from './routes-workspaces.js';
+const routes = [
+    ...workspaceRoutes,
+    ...openWorkspaceRoutes,
+    ...dispatchRoutes,
+    ...versionRoutes,
+    ...uiRoutes,
+    ...settingsRoutes,
+    ...taskRoutes,
+    ...workspaceMemoryDreamRoutes,
+    ...workspaceMemoryRoutes,
+    ...runtimeRoutes,
+    ...teamRecallRoutes,
+    ...teamMemoryRoutes,
+    ...teamRoutes,
+    ...fsRoutes,
+    ...marketplaceRoutes,
+    ...workflowRoutes,
+    ...workflowScheduleRoutes,
+    ...remoteRoutes,
+];
+export const matchRoute = (method, pathname) => {
+    for (const routeDefinition of routes) {
+        if (routeDefinition.method !== method) {
+            continue;
+        }
+        const params = matchPath(routeDefinition.path, pathname);
+        if (!params) {
+            continue;
+        }
+        return {
+            handler: routeDefinition.handler,
+            params,
+        };
+    }
+    return null;
+};

package/dist/src/server/runtime-database.d.ts

@@ -0,0 +1,3 @@
+import type { Database } from 'better-sqlite3';
+export declare const formatRuntimeDataDirOpenMessage: (dataDir: string, error: unknown) => string;
+export declare const openRuntimeDatabase: (dataDir?: string) => Database;

package/dist/src/server/runtime-database.js

@@ -0,0 +1,41 @@
+import { mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import BetterSqlite3 from 'better-sqlite3';
+import { initializeRuntimeDatabase } from './sqlite-schema.js';
+export const formatRuntimeDataDirOpenMessage = (dataDir, error) => {
+    const detail = error instanceof Error ? error.message : String(error);
+    return [
+        `Hive could not open its local data directory: ${dataDir}`,
+        detail,
+        '',
+        'Choose a writable local folder and start Hive with HIVE_DATA_DIR set, for example:',
+        '  PowerShell: $env:HIVE_DATA_DIR="C:\\HiveData"; hive',
+        '  cmd.exe:    set HIVE_DATA_DIR=C:\\HiveData && hive',
+    ].join('\n');
+};
+const createRuntimeDataDirOpenError = (dataDir, error) => new Error(formatRuntimeDataDirOpenMessage(dataDir, error), { cause: error });
+const configureRuntimeDatabase = (database, input) => {
+    database.pragma('busy_timeout = 5000');
+    if (!input.persistent)
+        return;
+    database.pragma('journal_mode = WAL');
+    database.pragma('synchronous = NORMAL');
+};
+export const openRuntimeDatabase = (dataDir) => {
+    let database;
+    if (dataDir) {
+        try {
+            mkdirSync(dataDir, { recursive: true });
+            database = new BetterSqlite3(join(dataDir, 'runtime.sqlite'));
+        }
+        catch (error) {
+            throw createRuntimeDataDirOpenError(dataDir, error);
+        }
+    }
+    else {
+        database = new BetterSqlite3(':memory:');
+    }
+    configureRuntimeDatabase(database, { persistent: Boolean(dataDir) });
+    initializeRuntimeDatabase(database);
+    return database;
+};

package/dist/src/server/runtime-message-builders.d.ts

@@ -0,0 +1,7 @@
+import type { MessageLogRecord } from './message-log-store.js';
+export declare const createUserInputMessage: (workspaceId: string, orchestratorId: string, text: string) => MessageLogRecord;
+export declare const createSendMessage: (workspaceId: string, workerId: string, text: string, fromAgentId?: string) => MessageLogRecord;
+export declare const createReportMessage: (workspaceId: string, workerId: string, text: string, status: string | undefined, artifacts: string[]) => MessageLogRecord;
+export declare const createStatusMessage: (workspaceId: string, workerId: string, text: string, artifacts: string[]) => MessageLogRecord;
+export declare const createSystemEnvSyncMessage: (workspaceId: string, agentId: string, text: string) => MessageLogRecord;
+export declare const createSystemRecoverySummaryMessage: (workspaceId: string, agentId: string, text: string) => MessageLogRecord;

package/dist/src/server/runtime-message-builders.js

@@ -0,0 +1,60 @@
+export const createUserInputMessage = (workspaceId, orchestratorId, text) => ({
+    createdAt: Date.now(),
+    text,
+    type: 'user_input',
+    workerId: orchestratorId,
+    workspaceId,
+});
+export const createSendMessage = (workspaceId, workerId, text, fromAgentId) => {
+    const message = {
+        createdAt: Date.now(),
+        text,
+        toAgentId: workerId,
+        type: 'send',
+        workerId,
+        workspaceId,
+    };
+    if (fromAgentId) {
+        message.fromAgentId = fromAgentId;
+    }
+    return message;
+};
+export const createReportMessage = (workspaceId, workerId, text, status, artifacts) => {
+    const message = {
+        artifacts,
+        createdAt: Date.now(),
+        fromAgentId: workerId,
+        text,
+        type: 'report',
+        workerId,
+        workspaceId,
+    };
+    if (status)
+        message.status = status;
+    return message;
+};
+export const createStatusMessage = (workspaceId, workerId, text, artifacts) => ({
+    artifacts,
+    createdAt: Date.now(),
+    fromAgentId: workerId,
+    text,
+    type: 'status',
+    workerId,
+    workspaceId,
+});
+export const createSystemEnvSyncMessage = (workspaceId, agentId, text) => ({
+    createdAt: Date.now(),
+    text,
+    toAgentId: agentId,
+    type: 'system_env_sync',
+    workerId: agentId,
+    workspaceId,
+});
+export const createSystemRecoverySummaryMessage = (workspaceId, agentId, text) => ({
+    createdAt: Date.now(),
+    text,
+    toAgentId: agentId,
+    type: 'system_recovery_summary',
+    workerId: agentId,
+    workspaceId,
+});

package/dist/src/server/runtime-restart-policy.d.ts

@@ -0,0 +1,18 @@
+import type { AgentRunStorePort } from './agent-runtime-ports.js';
+import type { FeatureFlags } from './feature-flags.js';
+import type { MessageLogHandle, MessageLogRecord, RecoveryMessage } from './message-log-store.js';
+import type { TasksFileService } from './tasks-file.js';
+import type { TeamMemoryInjectionService } from './team-memory-injection.js';
+import type { WorkspaceStore } from './workspace-store.js';
+export declare const buildRuntimeRestartPolicy: ({ agentRunStore, messageLogStore, memoryInjection, tasksFileService, workspaceStore, getFlags, }: {
+    agentRunStore: Pick<AgentRunStorePort, "listAgentRuns">;
+    messageLogStore: {
+        deleteMessage: (handle: MessageLogHandle) => void;
+        insertMessage: (record: MessageLogRecord) => MessageLogHandle;
+        listMessagesForRecovery: (workspaceId: string, sinceMs: number) => RecoveryMessage[];
+    };
+    memoryInjection?: TeamMemoryInjectionService;
+    tasksFileService: Pick<TasksFileService, "readTasks">;
+    workspaceStore: Pick<WorkspaceStore, "getWorkspaceSnapshot">;
+    getFlags?: () => FeatureFlags;
+}) => import("./restart-policy.js").RestartPolicy;

package/dist/src/server/runtime-restart-policy.js

@@ -0,0 +1,12 @@
+import { createRestartPolicy } from './restart-policy.js';
+// Narrow helper keeps runtime-store under the hard line cap.
+export const buildRuntimeRestartPolicy = ({ agentRunStore, messageLogStore, memoryInjection, tasksFileService, workspaceStore, getFlags, }) => createRestartPolicy({
+    deleteMessage: messageLogStore.deleteMessage,
+    getWorkspaceSnapshot: workspaceStore.getWorkspaceSnapshot,
+    insertMessage: messageLogStore.insertMessage,
+    listAgentRuns: agentRunStore.listAgentRuns,
+    listMessagesForRecovery: messageLogStore.listMessagesForRecovery,
+    readTasks: tasksFileService.readTasks,
+    ...(getFlags ? { getFlags } : {}),
+    ...(memoryInjection ? { memoryInjection } : {}),
+});

package/dist/src/server/runtime-store-contract.d.ts

@@ -0,0 +1,162 @@
+import type { IncomingMessage } from 'node:http';
+import type { AgentSummary, TeamListItem, WorkspaceSummary } from '../shared/types.js';
+import type { AgentManager } from './agent-manager.js';
+import type { AgentLaunchConfigInput, PersistedAgentRun } from './agent-run-store.js';
+import type { LiveAgentRun } from './agent-runtime-types.js';
+import type { DispatchRecord, ListDispatchesOptions } from './dispatch-ledger-store.js';
+import type { RecoveryMessage } from './message-log-store.js';
+import type { PtyOutputBus } from './pty-output-bus.js';
+import type { RemoteAuditStore } from './remote-audit-store.js';
+import type { DeviceSessionProvider } from './remote-device-session.js';
+import type { RemoteDeviceRecord, RemoteDeviceStore } from './remote-device-store.js';
+import type { RemotePairing } from './remote-pairing.js';
+import type { RemoteTunnel, TunnelStatus } from './remote-tunnel.js';
+import type { SettingsStore } from './settings-store.js';
+import type { DreamRunRecord } from './team-memory-dream-store.js';
+import type { AddMemoryEntryInput, LogMemoryInjectionsInput, MemoryEntryWithSources, MemoryInjectionWithMemory, MemoryListOptions, MemorySearchOptions, MemorySearchResult } from './team-memory-store.js';
+import type { CancelTaskInput, DispatchTaskInput, ReportTaskInput, ReportTaskResult, StatusTaskInput } from './team-operations.js';
+import type { RecallOptions, RecallResult } from './team-recall-store.js';
+import type { TerminalRunSummary } from './terminal-input-profile.js';
+import type { WorkflowDispatchAwaiter } from './workflow-dispatch-awaiter.js';
+import type { WorkflowRunRecord } from './workflow-run-store.js';
+import type { RunInlineWorkflowInput, RunWorkflowInput, WorkflowRunner } from './workflow-runner.js';
+import type { WorkflowScheduleRecord } from './workflow-schedule-store.js';
+import type { WorkerInput, WorkspaceRecord } from './workspace-store.js';
+export interface RuntimeStore {
+    close: () => Promise<void>;
+    createWorkspace: (path: string, name: string) => WorkspaceSummary;
+    deleteWorkspace: (workspaceId: string) => Promise<void>;
+    listWorkspaces: () => WorkspaceSummary[];
+    addWorker: (workspaceId: string, input: WorkerInput) => AgentSummary;
+    addWorkerWithLaunch: (workspaceId: string, input: WorkerInput, launchConfig: AgentLaunchConfigInput) => AgentSummary;
+    deleteWorker: (workspaceId: string, workerId: string) => void;
+    renameWorker: (workspaceId: string, workerId: string, name: string) => AgentSummary;
+    recordUserInput: (workspaceId: string, orchestratorId: string, text: string) => void;
+    dispatchTask: (workspaceId: string, workerId: string, text: string, input?: DispatchTaskInput) => Promise<DispatchRecord>;
+    dispatchTaskByWorkerName: (workspaceId: string, workerName: string, text: string, input?: DispatchTaskInput) => Promise<DispatchRecord & {
+        restartedWorker: boolean;
+    }>;
+    reportTask: (workspaceId: string, workerId: string, input?: ReportTaskInput) => ReportTaskResult;
+    /** Flush any reports stranded by a prior orchestrator outage. Safe no-op
+     *  when the orchestrator is down or the outbox is empty. */
+    drainReportOutbox: (workspaceId: string) => void;
+    statusTask: (workspaceId: string, workerId: string, input?: StatusTaskInput) => ReportTaskResult;
+    cancelTask: (workspaceId: string, dispatchId: string, input: CancelTaskInput) => ReportTaskResult;
+    listDispatches: (workspaceId: string, options?: ListDispatchesOptions) => DispatchRecord[];
+    listWorkers: (workspaceId: string) => TeamListItem[];
+    getLastPtyLineForAgent: (workspaceId: string, agentId: string) => string | null;
+    getWorkspaceSnapshot: (workspaceId: string) => WorkspaceRecord;
+    getWorker: (workspaceId: string, workerId: string) => AgentSummary;
+    getAgent: (workspaceId: string, agentId: string) => AgentSummary;
+    getPtyOutputBus: () => PtyOutputBus;
+    listTerminalRuns: (workspaceId: string) => TerminalRunSummary[];
+    closeWorkspaceShell: (workspaceId: string, runId: string) => boolean;
+    startWorkspaceShell: (workspaceId: string) => Promise<LiveAgentRun>;
+    configureAgentLaunch: (workspaceId: string, agentId: string, input: AgentLaunchConfigInput) => void;
+    peekAgentLaunchConfig: (workspaceId: string, agentId: string) => AgentLaunchConfigInput | undefined;
+    startAgent: (workspaceId: string, agentId: string, input: StartAgentOptions) => Promise<LiveAgentRun>;
+    autostartConfiguredAgents: (input: StartAgentOptions) => Promise<Array<{
+        agent_id: string;
+        error: string | null;
+        ok: boolean;
+        run_id: string | null;
+        workspace_id: string;
+    }>>;
+    startWorkspaceWatch: (workspaceId: string) => Promise<void>;
+    getLiveRun: (runId: string) => LiveAgentRun;
+    getActiveRunByAgentId: (workspaceId: string, agentId: string) => LiveAgentRun | undefined;
+    registerTasksListener: (listener: (workspaceId: string, content: string) => void) => () => void;
+    listAgentRuns: (agentId: string) => PersistedAgentRun[];
+    listMessagesForRecovery: (workspaceId: string, sinceMs: number) => RecoveryMessage[];
+    recallMessages: (workspaceId: string, query: string, options?: RecallOptions) => RecallResult[];
+    addMemoryEntry: (input: AddMemoryEntryInput) => MemoryEntryWithSources;
+    approveMemoryCandidate: (workspaceId: string, memoryId: string) => MemoryEntryWithSources;
+    archiveMemoryEntry: (workspaceId: string, memoryId: string) => MemoryEntryWithSources;
+    getMemoryEntry: (workspaceId: string, memoryId: string) => MemoryEntryWithSources | undefined;
+    listMemoryEntries: (workspaceId: string, options?: MemoryListOptions) => MemoryEntryWithSources[];
+    listMemoryInjectionsForDispatch: (workspaceId: string, dispatchId: string) => MemoryInjectionWithMemory[];
+    logMemoryInjections: (input: LogMemoryInjectionsInput) => string[];
+    rejectMemoryCandidate: (workspaceId: string, memoryId: string) => MemoryEntryWithSources;
+    searchMemoryEntries: (workspaceId: string, query: string, options?: MemorySearchOptions) => MemorySearchResult[];
+    setMemoryDisabled: (workspaceId: string, memoryId: string, disabled: boolean) => MemoryEntryWithSources;
+    setMemoryPinned: (workspaceId: string, memoryId: string, pinned: boolean) => MemoryEntryWithSources;
+    listMemoryDreamRuns: (workspaceId: string, limit?: number) => DreamRunRecord[];
+    revertMemoryDream: (workspaceId: string, runId: string) => DreamRunRecord;
+    runMemoryDream: (workspaceId: string) => Promise<DreamRunRecord>;
+    tickMemoryDreamScheduler: (now?: number) => Promise<void>;
+    peekAgentToken: (agentId: string) => string | undefined;
+    pauseTerminalRun: (runId: string) => void;
+    resizeAgentRun: (runId: string, cols: number, rows: number) => void;
+    resumeTerminalRun: (runId: string) => void;
+    settings: SettingsStore;
+    writeRunInput: (runId: string, input: Buffer | string) => void;
+    getUiToken: () => string;
+    stopAgentRun: (runId: string) => void;
+    validateAgentToken: (agentId: string, token: string | undefined) => boolean;
+    validateUiToken: (token: string | undefined) => boolean;
+    authorizeRemoteTunnelRequest: (request: IncomingMessage) => boolean;
+    getRemoteTunnelSecret: () => string;
+    getRemoteAuditStore: () => RemoteAuditStore;
+    getRemoteDeviceSessions: () => DeviceSessionProvider;
+    getRemotePairing: () => RemotePairing;
+    confirmRemotePairing: (pairingId: string, name?: string) => Promise<RemoteDeviceRecord | null>;
+    getRemoteDeviceStore: () => RemoteDeviceStore;
+    getRemoteTunnelStatus: () => TunnelStatus;
+    setRemoteTunnelStatus: (status: TunnelStatus) => void;
+    bindRemoteTunnel: (tunnel: RemoteTunnel) => void;
+    setRemoteEnabled: (enabled: boolean) => void;
+    revokeRemoteDevice: (deviceId: string) => boolean;
+    getWorkflowDispatchAwaiter: () => WorkflowDispatchAwaiter;
+    runWorkflow: (input: RunWorkflowInput) => Promise<WorkflowRunRecord>;
+    startWorkflow: (input: RunWorkflowInput) => Promise<WorkflowRunRecord>;
+    startWorkflowInline: (input: RunInlineWorkflowInput) => Promise<WorkflowRunRecord>;
+    stopWorkflowRun: (runId: string) => boolean;
+    getWorkflowRun: (runId: string) => WorkflowRunRecord | undefined;
+    listWorkspaceWorkflowRuns: (workspaceId: string) => WorkflowRunRecord[];
+    listWorkflowRunDispatches: (runId: string) => DispatchRecord[];
+    listWorkflowRunLogs: (runId: string) => Array<{
+        id: number;
+        ts: number;
+        message: string;
+    }>;
+    createWorkflowSchedule: (input: {
+        workspaceId: string;
+        scriptPath: string;
+        cron: string;
+        nextRunAt: number;
+        args?: unknown;
+        enabled?: boolean;
+    }) => WorkflowScheduleRecord;
+    scheduleWorkflowInline: (input: {
+        workspaceId: string;
+        source: string;
+        name: string;
+        cron: string;
+        nextRunAt: number;
+        args?: unknown;
+    }) => Promise<WorkflowScheduleRecord>;
+    updateWorkflowSchedule: (id: string, input: {
+        cron?: string;
+        args?: unknown;
+        enabled?: boolean;
+        lastRunAt?: number;
+        nextRunAt?: number;
+    }) => void;
+    getWorkflowSchedule: (id: string) => WorkflowScheduleRecord | undefined;
+    listWorkspaceWorkflowSchedules: (workspaceId: string) => WorkflowScheduleRecord[];
+    deleteWorkflowSchedule: (id: string) => void;
+}
+export interface RuntimeStoreOptions {
+    dataDir?: string;
+    agentManager?: AgentManager;
+}
+export interface StartAgentOptions {
+    hivePort: string;
+}
+export type RuntimeWorkflowRuntime = {
+    runner: WorkflowRunner;
+    scheduler: {
+        close: () => void;
+        start: () => void;
+    };
+};

package/dist/src/server/runtime-store-contract.js

@@ -0,0 +1 @@
+export {};

package/dist/src/server/runtime-store-dream.d.ts

@@ -0,0 +1,23 @@
+import type { DreamRunRecord } from './team-memory-dream-store.js';
+interface RuntimeStoreDreamServices {
+    teamMemoryDreamRunner: {
+        runManual: (workspaceId: string) => Promise<DreamRunRecord>;
+    };
+    teamMemoryDreamScheduler: {
+        tick: (now?: number) => Promise<void>;
+    };
+    teamMemoryDreamStore: {
+        listRuns: (workspaceId: string, limit?: number) => DreamRunRecord[];
+        revertRun: (workspaceId: string, runId: string) => DreamRunRecord;
+    };
+    teamMemoryExport: {
+        schedule: (workspaceId: string) => void;
+    };
+}
+export declare const createRuntimeStoreDreamMethods: (services: RuntimeStoreDreamServices) => {
+    listMemoryDreamRuns(workspaceId: string, limit?: number): DreamRunRecord[];
+    revertMemoryDream(workspaceId: string, runId: string): DreamRunRecord;
+    runMemoryDream(workspaceId: string): Promise<DreamRunRecord>;
+    tickMemoryDreamScheduler(now?: number): Promise<void>;
+};
+export {};

package/dist/src/server/runtime-store-dream.js

@@ -0,0 +1,16 @@
+export const createRuntimeStoreDreamMethods = (services) => ({
+    listMemoryDreamRuns(workspaceId, limit) {
+        return services.teamMemoryDreamStore.listRuns(workspaceId, limit);
+    },
+    revertMemoryDream(workspaceId, runId) {
+        const run = services.teamMemoryDreamStore.revertRun(workspaceId, runId);
+        services.teamMemoryExport.schedule(workspaceId);
+        return run;
+    },
+    runMemoryDream(workspaceId) {
+        return services.teamMemoryDreamRunner.runManual(workspaceId);
+    },
+    tickMemoryDreamScheduler(now) {
+        return services.teamMemoryDreamScheduler.tick(now);
+    },
+});

package/dist/src/server/runtime-store-helpers.d.ts

@@ -0,0 +1,115 @@
+import type { AgentManager } from './agent-manager.js';
+import { type AgentLaunchConfigInput, createAgentRunStore } from './agent-run-store.js';
+import { createAgentRuntime } from './agent-runtime.js';
+import type { LiveAgentRun } from './agent-runtime-types.js';
+import { createDispatchLedgerStore } from './dispatch-ledger-store.js';
+import { createMessageLogStore } from './message-log-store.js';
+import type { PtyOutputBus } from './pty-output-bus.js';
+import { type RemoteAuditStore } from './remote-audit-store.js';
+import type { DeviceSessionProvider } from './remote-device-session.js';
+import { type RemoteDeviceStore } from './remote-device-store.js';
+import { type RemotePairing } from './remote-pairing.js';
+import { openRuntimeDatabase } from './runtime-database.js';
+import { createSettingsStore } from './settings-store.js';
+import { createTasksFileService } from './tasks-file.js';
+import { createTasksFileWatcher } from './tasks-file-watcher.js';
+import { createTeamMemoryDreamRunner } from './team-memory-dream-runner.js';
+import { createTeamMemoryDreamScheduler } from './team-memory-dream-scheduler.js';
+import { createTeamMemoryDreamStore } from './team-memory-dream-store.js';
+import { createTeamMemoryExportService } from './team-memory-export.js';
+import { createTeamMemoryStore } from './team-memory-store.js';
+import { createTeamOperations } from './team-operations.js';
+import { createTeamRecallStore } from './team-recall-store.js';
+import { createUiAuth } from './ui-auth.js';
+import { createWebhookNotifier } from './webhook-notifier.js';
+import { type WorkerOutputTracker } from './worker-output-tracker.js';
+import { type WorkflowDispatchAwaiter } from './workflow-dispatch-awaiter.js';
+import { createWorkflowRunLogStore } from './workflow-run-log-store.js';
+import { createWorkflowRunStore } from './workflow-run-store.js';
+import { createWorkflowScheduleStore } from './workflow-schedule-store.js';
+import { createWorkspaceShellRuntime } from './workspace-shell-runtime.js';
+import { createWorkspaceStore } from './workspace-store.js';
+export interface RuntimeStoreServices {
+    agentRunStore: ReturnType<typeof createAgentRunStore>;
+    agentRuntime: ReturnType<typeof createAgentRuntime>;
+    db: ReturnType<typeof openRuntimeDatabase>;
+    dispatchLedgerStore: ReturnType<typeof createDispatchLedgerStore>;
+    messageLogStore: ReturnType<typeof createMessageLogStore>;
+    remoteAuditStore: RemoteAuditStore;
+    remoteDeviceSessions: DeviceSessionProvider;
+    remoteDeviceStore: RemoteDeviceStore;
+    remotePairing: RemotePairing;
+    settings: ReturnType<typeof createSettingsStore>;
+    shellRuntime: ReturnType<typeof createWorkspaceShellRuntime>;
+    tasksFileWatcher: ReturnType<typeof createTasksFileWatcher>;
+    tasksFileWatchCallbacks: Set<(workspaceId: string, content: string) => void>;
+    tasksFileService: ReturnType<typeof createTasksFileService>;
+    teamMemoryDreamRunner: ReturnType<typeof createTeamMemoryDreamRunner>;
+    teamMemoryDreamScheduler: ReturnType<typeof createTeamMemoryDreamScheduler>;
+    teamMemoryDreamStore: ReturnType<typeof createTeamMemoryDreamStore>;
+    teamMemoryStore: ReturnType<typeof createTeamMemoryStore>;
+    teamMemoryExport: ReturnType<typeof createTeamMemoryExportService>;
+    teamRecallStore: ReturnType<typeof createTeamRecallStore>;
+    teamOps: ReturnType<typeof createTeamOperations>;
+    uiAuth: ReturnType<typeof createUiAuth>;
+    webhookNotifier: ReturnType<typeof createWebhookNotifier>;
+    workerOutputTracker: WorkerOutputTracker | null;
+    workflowDispatchAwaiter: WorkflowDispatchAwaiter;
+    workflowRunLogStore: ReturnType<typeof createWorkflowRunLogStore>;
+    workflowRunStore: ReturnType<typeof createWorkflowRunStore>;
+    workflowScheduleStore: ReturnType<typeof createWorkflowScheduleStore>;
+    workspaceStore: ReturnType<typeof createWorkspaceStore>;
+}
+interface CreateRuntimeStoreServicesOptions {
+    agentManager?: AgentManager;
+    dataDir?: string;
+}
+interface CreateRuntimeStoreLifecycleOptions {
+    agentManager?: AgentManager;
+    services: RuntimeStoreServices;
+}
+export declare const logTasksFileWatchStartError: (workspaceId: string, error: unknown) => void;
+export declare const createRuntimeStoreServices: (options?: CreateRuntimeStoreServicesOptions) => RuntimeStoreServices;
+export declare const createRuntimeStoreLifecycle: ({ agentManager, services, }: CreateRuntimeStoreLifecycleOptions) => {
+    close: () => Promise<void>;
+    configureAgentLaunch: (workspaceId: string, agentId: string, input: AgentLaunchConfigInput) => void;
+    peekAgentLaunchConfig: (workspaceId: string, agentId: string) => AgentLaunchConfigInput | undefined;
+    deleteWorkspaceShell: (workspaceId: string) => void;
+    closeWorkspaceShell: (workspaceId: string, runId: string) => boolean;
+    getLiveRun: (runId: string) => LiveAgentRun;
+    getPtyOutputBus: () => PtyOutputBus;
+    listTerminalRuns: (workspaceId: string) => {
+        agent_id: string;
+        agent_name: string;
+        run_id: string;
+        status: import("./agent-manager.js").RunStatus;
+        terminal_input_profile: import("./terminal-input-profile.js").TerminalInputProfile;
+    }[];
+    startAgent: (workspaceId: string, agentId: string, input: {
+        hivePort: string;
+    }) => Promise<LiveAgentRun>;
+    startWorkspaceShell: (workspaceId: string) => Promise<LiveAgentRun>;
+    autostartConfiguredAgents: (input: {
+        hivePort: string;
+    }) => Promise<({
+        agent_id: string;
+        error: null;
+        ok: boolean;
+        run_id: string;
+        workspace_id: string;
+    } | {
+        agent_id: string;
+        error: string;
+        ok: boolean;
+        run_id: null;
+        workspace_id: string;
+    })[]>;
+    registerTasksListener: (listener: (workspaceId: string, content: string) => void) => () => void;
+    startWorkspaceWatch: (workspaceId: string) => Promise<void>;
+    writeRunInput: (runId: string, input: Buffer | string) => void;
+    pauseTerminalRun: (runId: string) => void;
+    resizeTerminalRun: (runId: string, cols: number, rows: number) => void;
+    resumeTerminalRun: (runId: string) => void;
+    stopTerminalRun: (runId: string) => void;
+};
+export {};