@tt-a1i/hive 2.0.2 → 2.1.0

package/dist/src/server/routes-workspace-uploads.js

@@ -0,0 +1,154 @@
+import { BadRequestError, HttpError, PayloadTooLargeError } from './http-errors.js';
+import { HIVE_REMOTE_DEVICE_HEADER } from './remote-loopback-auth.js';
+import { getRequiredParam, readJsonBody, route, sendJson } from './route-helpers.js';
+import { requireUiTokenFromRequest } from './ui-auth-helpers.js';
+import { WORKSPACE_UPLOAD_JSON_BODY_LIMIT_BYTES, WORKSPACE_UPLOAD_MAX_BYTES, } from './upload-limits.js';
+const BASE64_RE = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+const MAX_UPLOAD_LIST_LIMIT = 100;
+// Bounds the multi-pass sanitizer cost: a body-limit-sized filename string
+// would otherwise burn seconds of CPU before the final 180-char truncation.
+const MAX_FILENAME_INPUT_LENGTH = 1024;
+const UPLOAD_LIMIT_LABEL = `${WORKSPACE_UPLOAD_MAX_BYTES / (1024 * 1024)}MB`;
+const assertWorkspaceExists = (store, workspaceId) => {
+    if (!store.listWorkspaces().some((workspace) => workspace.id === workspaceId)) {
+        throw new HttpError(404, 'Workspace not found');
+    }
+};
+const readUploadBody = async (request) => {
+    try {
+        return await readJsonBody(request, {
+            limitBytes: WORKSPACE_UPLOAD_JSON_BODY_LIMIT_BYTES,
+        });
+    }
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            throw new BadRequestError('Request body must be valid JSON');
+        }
+        throw error;
+    }
+};
+const decodeUploadData = (value) => {
+    if (typeof value !== 'string') {
+        throw new BadRequestError('data must be a base64 string');
+    }
+    const data = value.trim();
+    if (data.length === 0)
+        return Buffer.alloc(0);
+    if (data.length % 4 !== 0 || !BASE64_RE.test(data)) {
+        throw new BadRequestError('data must be valid base64');
+    }
+    const padding = data.endsWith('==') ? 2 : data.endsWith('=') ? 1 : 0;
+    const decodedBytes = (data.length / 4) * 3 - padding;
+    if (decodedBytes > WORKSPACE_UPLOAD_MAX_BYTES) {
+        throw new PayloadTooLargeError(`Upload exceeds the ${UPLOAD_LIMIT_LABEL} limit`);
+    }
+    const buffer = Buffer.from(data, 'base64');
+    if (buffer.byteLength !== decodedBytes) {
+        throw new BadRequestError('data must be valid base64');
+    }
+    return buffer;
+};
+const readFilename = (value) => {
+    if (value === undefined || value === null)
+        return 'upload';
+    if (typeof value !== 'string')
+        throw new BadRequestError('filename must be a string');
+    return value.slice(0, MAX_FILENAME_INPUT_LENGTH);
+};
+const readMimeType = (value) => {
+    if (value === undefined || value === null)
+        return null;
+    if (typeof value !== 'string')
+        throw new BadRequestError('mime_type must be a string');
+    return value;
+};
+const readRemoteDeviceId = (request, tunnelRequest) => {
+    if (!tunnelRequest)
+        return null;
+    const raw = request.headers[HIVE_REMOTE_DEVICE_HEADER];
+    const value = Array.isArray(raw) ? raw[0] : raw;
+    if (typeof value !== 'string')
+        return null;
+    const trimmed = value.trim();
+    if (!trimmed || trimmed.length > 128 || /[\r\n]/.test(trimmed))
+        return null;
+    return trimmed;
+};
+const serializeUpload = (record) => ({
+    created_at: record.createdAt,
+    id: record.id,
+    mime_type: record.mimeType,
+    original_name: record.originalName,
+    size_bytes: record.sizeBytes,
+    url: `/api/workspaces/${encodeURIComponent(record.workspaceId)}/uploads/${encodeURIComponent(record.id)}`,
+    workspace_id: record.workspaceId,
+});
+const readListLimit = (request) => {
+    const url = new URL(request.url ?? '/', 'http://127.0.0.1');
+    const raw = url.searchParams.get('limit');
+    if (raw === null)
+        return undefined;
+    if (!/^(0|[1-9][0-9]*)$/.test(raw)) {
+        throw new BadRequestError('limit must be a non-negative integer');
+    }
+    const limit = Number(raw);
+    if (!Number.isSafeInteger(limit) || limit < 1 || limit > MAX_UPLOAD_LIST_LIMIT) {
+        throw new BadRequestError(`limit must be between 1 and ${MAX_UPLOAD_LIST_LIMIT}`);
+    }
+    return limit;
+};
+const encodeDispositionValue = (value) => encodeURIComponent(value).replace(/['()*]/g, (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`);
+const contentDispositionFor = (filename) => {
+    const fallback = filename
+        .replace(/[^\x20-\x7e]/g, '_')
+        .replace(/[\\"]/g, '_')
+        .trim()
+        .slice(0, 120) || 'upload';
+    return `attachment; filename="${fallback}"; filename*=UTF-8''${encodeDispositionValue(filename)}`;
+};
+export const workspaceUploadRoutes = [
+    route('GET', '/api/workspaces/:workspaceId/uploads', ({ params, request, response, store }) => {
+        const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Workspace id is required');
+        if (!workspaceId)
+            return;
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        assertWorkspaceExists(store, workspaceId);
+        sendJson(response, 200, store.listWorkspaceUploads(workspaceId, readListLimit(request)).map(serializeUpload));
+    }),
+    route('POST', '/api/workspaces/:workspaceId/uploads', async ({ params, request, response, store }) => {
+        const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Workspace id is required');
+        if (!workspaceId)
+            return;
+        const tunnelRequest = store.authorizeRemoteTunnelRequest(request);
+        requireUiTokenFromRequest(request, store.validateUiToken, () => tunnelRequest);
+        assertWorkspaceExists(store, workspaceId);
+        const body = await readUploadBody(request);
+        const record = await store.saveWorkspaceUpload({
+            data: decodeUploadData(body.data),
+            mimeType: readMimeType(body.mime_type),
+            originalName: readFilename(body.filename),
+            remoteDeviceId: readRemoteDeviceId(request, tunnelRequest),
+            workspaceId,
+        });
+        sendJson(response, 201, serializeUpload(record));
+    }),
+    route('GET', '/api/workspaces/:workspaceId/uploads/:uploadId', async ({ params, request, response, store }) => {
+        const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Workspace id and upload id are required');
+        const uploadId = getRequiredParam(response, params, 'uploadId', 'Workspace id and upload id are required');
+        if (!workspaceId || !uploadId)
+            return;
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        assertWorkspaceExists(store, workspaceId);
+        const upload = await store.readWorkspaceUpload(workspaceId, uploadId);
+        if (!upload) {
+            throw new HttpError(404, 'Upload not found');
+        }
+        response.statusCode = 200;
+        response.setHeader('content-type', upload.record.mimeType);
+        response.setHeader('content-length', String(upload.data.byteLength));
+        response.setHeader('content-disposition', contentDispositionFor(upload.record.originalName));
+        response.setHeader('x-content-type-options', 'nosniff');
+        response.setHeader('cache-control', 'private, max-age=0, must-revalidate');
+        response.end(upload.data);
+    }),
+];

package/dist/src/server/routes-workspaces.js

@@ -7,7 +7,33 @@ import { enrichTeamList } from './team-list-enrichment.js';
 import { serializeTeamListItem } from './team-list-serializer.js';
 import { requireUiTokenFromRequest } from './ui-auth-helpers.js';
 import { validateWorkspacePath } from './workspace-path-validation.js';
-import { getOrchestratorId } from './workspace-store-support.js';
+import { getOrchestratorId, getWorkflowAgentId } from './workspace-store-support.js';
+/* #35: fold each worker's open dispatches (id, age, status, task preview)
+   into the team list payload. Display-only ages — no timeout or heartbeat is
+   derived from them; `queued` rows age from createdAt (submittedAt is null
+   until delivery). */
+const serializeTeamListWithOpenDispatches = (store, workspaceId) => {
+    const now = Date.now();
+    const workflowAgentId = getWorkflowAgentId(workspaceId);
+    const openByWorker = new Map();
+    for (const dispatch of store.listOpenDispatches(workspaceId)) {
+        if (dispatch.status !== 'queued' && dispatch.status !== 'submitted')
+            continue;
+        // Workflow-owned dispatches are the runner's business: handing their ids
+        // to the orchestrator invites a `team cancel` that wedges the run.
+        if (dispatch.workflowRunId !== null || dispatch.fromAgentId === workflowAgentId)
+            continue;
+        const list = openByWorker.get(dispatch.toAgentId) ?? [];
+        list.push({
+            id: dispatch.id,
+            status: dispatch.status,
+            age_minutes: Math.max(0, Math.floor((now - (dispatch.submittedAt ?? dispatch.createdAt)) / 60_000)),
+            task_preview: dispatch.text.slice(0, 60),
+        });
+        openByWorker.set(dispatch.toAgentId, list);
+    }
+    return enrichTeamList(workspaceId, store, store.listWorkers(workspaceId)).map((worker) => serializeTeamListItem(worker, openByWorker.get(worker.id)));
+};
 const getSerializedWorker = (workspaceId, workerId, store) => {
     const worker = store.listWorkers(workspaceId).find((item) => item.id === workerId);
     if (!worker) {
@@ -61,7 +87,7 @@ export const workspaceRoutes = [
             return;
         }
         requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
-        sendJson(response, 200, enrichTeamList(workspaceId, store, store.listWorkers(workspaceId)).map(serializeTeamListItem));
+        sendJson(response, 200, serializeTeamListWithOpenDispatches(store, workspaceId));
     }),
     route('GET', '/api/workspaces/:workspaceId/team', ({ params, request, response, store }) => {
         const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Workspace id is required');
@@ -83,7 +109,7 @@ export const workspaceRoutes = [
         // it is reachable again. Cheap (indexed, usually empty) and a safe no-op
         // for non-orchestrator callers.
         store.drainReportOutbox(workspaceId);
-        sendJson(response, 200, enrichTeamList(workspaceId, store, store.listWorkers(workspaceId)).map(serializeTeamListItem));
+        sendJson(response, 200, serializeTeamListWithOpenDispatches(store, workspaceId));
     }),
     route('POST', '/api/workspaces/:workspaceId/workers', async ({ params, request, response, store }) => {
         const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Workspace id is required');

package/dist/src/server/routes.js

@@ -1,10 +1,13 @@
 import { matchPath } from './route-helpers.js';
+import { actionCenterRoutes } from './routes-action-center.js';
+import { diagnosticsRoutes } from './routes-diagnostics.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 { scenarioRoutes } from './routes-scenarios.js';
 import { settingsRoutes } from './routes-settings.js';
 import { taskRoutes } from './routes-tasks.js';
 import { teamRoutes } from './routes-team.js';
@@ -16,10 +19,15 @@ 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 { workspaceUploadRoutes } from './routes-workspace-uploads.js';
 import { workspaceRoutes } from './routes-workspaces.js';
 const routes = [
     ...workspaceRoutes,
+    ...scenarioRoutes,
+    ...workspaceUploadRoutes,
     ...openWorkspaceRoutes,
+    ...actionCenterRoutes,
+    ...diagnosticsRoutes,
     ...dispatchRoutes,
     ...versionRoutes,
     ...uiRoutes,

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

@@ -3,5 +3,4 @@ export declare const createUserInputMessage: (workspaceId: string, orchestratorI
 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

@@ -42,14 +42,6 @@ export const createStatusMessage = (workspaceId, workerId, text, artifacts) => (
     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,

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

@@ -11,6 +11,7 @@ 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 { MemoryDreamInput } from './runtime-store-dream.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';
@@ -22,6 +23,7 @@ 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';
+import type { SaveWorkspaceUploadInput, WorkspaceUploadRecord } from './workspace-upload-store.js';
 export interface RuntimeStore {
     close: () => Promise<void>;
     createWorkspace: (path: string, name: string) => WorkspaceSummary;
@@ -35,6 +37,7 @@ export interface RuntimeStore {
     dispatchTask: (workspaceId: string, workerId: string, text: string, input?: DispatchTaskInput) => Promise<DispatchRecord>;
     dispatchTaskByWorkerName: (workspaceId: string, workerName: string, text: string, input?: DispatchTaskInput) => Promise<DispatchRecord & {
         restartedWorker: boolean;
+        queuedForStoppedWorker?: boolean;
     }>;
     reportTask: (workspaceId: string, workerId: string, input?: ReportTaskInput) => ReportTaskResult;
     /** Flush any reports stranded by a prior orchestrator outage. Safe no-op
@@ -43,6 +46,8 @@ export interface RuntimeStore {
     statusTask: (workspaceId: string, workerId: string, input?: StatusTaskInput) => ReportTaskResult;
     cancelTask: (workspaceId: string, dispatchId: string, input: CancelTaskInput) => ReportTaskResult;
     listDispatches: (workspaceId: string, options?: ListDispatchesOptions) => DispatchRecord[];
+    listOpenDispatches: (workspaceId: string) => DispatchRecord[];
+    listRecentDispatches: (workspaceId: string, limit?: number) => DispatchRecord[];
     listWorkers: (workspaceId: string) => TeamListItem[];
     getLastPtyLineForAgent: (workspaceId: string, agentId: string) => string | null;
     getWorkspaceSnapshot: (workspaceId: string) => WorkspaceRecord;
@@ -80,6 +85,8 @@ export interface RuntimeStore {
     searchMemoryEntries: (workspaceId: string, query: string, options?: MemorySearchOptions) => MemorySearchResult[];
     setMemoryDisabled: (workspaceId: string, memoryId: string, disabled: boolean) => MemoryEntryWithSources;
     setMemoryPinned: (workspaceId: string, memoryId: string, pinned: boolean) => MemoryEntryWithSources;
+    applyMemoryDreamRun: (workspaceId: string, runId: string, rawOps: unknown) => DreamRunRecord;
+    getMemoryDreamInput: (workspaceId: string, runId: string) => MemoryDreamInput;
     listMemoryDreamRuns: (workspaceId: string, limit?: number) => DreamRunRecord[];
     revertMemoryDream: (workspaceId: string, runId: string) => DreamRunRecord;
     runMemoryDream: (workspaceId: string) => Promise<DreamRunRecord>;
@@ -102,6 +109,8 @@ export interface RuntimeStore {
     confirmRemotePairing: (pairingId: string, name?: string) => Promise<RemoteDeviceRecord | null>;
     getRemoteDeviceStore: () => RemoteDeviceStore;
     getRemoteTunnelStatus: () => TunnelStatus;
+    /** Local retention signals (issue #23): per-day protocol event counts. Local-only, never transmitted. */
+    getRetentionSignals: () => import('./protocol-event-stats.js').RetentionSignals;
     setRemoteTunnelStatus: (status: TunnelStatus) => void;
     bindRemoteTunnel: (tunnel: RemoteTunnel) => void;
     setRemoteEnabled: (enabled: boolean) => void;
@@ -119,6 +128,12 @@ export interface RuntimeStore {
         ts: number;
         message: string;
     }>;
+    saveWorkspaceUpload: (input: SaveWorkspaceUploadInput) => Promise<WorkspaceUploadRecord>;
+    listWorkspaceUploads: (workspaceId: string, limit?: number) => WorkspaceUploadRecord[];
+    readWorkspaceUpload: (workspaceId: string, uploadId: string) => Promise<{
+        data: Buffer;
+        record: WorkspaceUploadRecord;
+    } | undefined>;
     createWorkflowSchedule: (input: {
         workspaceId: string;
         scriptPath: string;

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

@@ -1,4 +1,9 @@
-import type { DreamRunRecord } from './team-memory-dream-store.js';
+import { type DreamMessageInput, type DreamRunRecord } from './team-memory-dream-store.js';
+import type { MemoryEntryWithSources } from './team-memory-store.js';
+export interface MemoryDreamInput {
+    prompt: string;
+    run: DreamRunRecord;
+}
 interface RuntimeStoreDreamServices {
     teamMemoryDreamRunner: {
         runManual: (workspaceId: string) => Promise<DreamRunRecord>;
@@ -7,14 +12,22 @@ interface RuntimeStoreDreamServices {
         tick: (now?: number) => Promise<void>;
     };
     teamMemoryDreamStore: {
+        applyAndCompleteRun: (workspaceId: string, runId: string, rawOps: unknown) => DreamRunRecord;
+        getRun: (runId: string) => DreamRunRecord | undefined;
+        listInputMessages: (workspaceId: string, from: number | null, to: number | null) => DreamMessageInput[];
         listRuns: (workspaceId: string, limit?: number) => DreamRunRecord[];
         revertRun: (workspaceId: string, runId: string) => DreamRunRecord;
     };
+    teamMemoryStore: {
+        listAllEntries: (workspaceId: string) => MemoryEntryWithSources[];
+    };
     teamMemoryExport: {
         schedule: (workspaceId: string) => void;
     };
 }
 export declare const createRuntimeStoreDreamMethods: (services: RuntimeStoreDreamServices) => {
+    applyMemoryDreamRun(workspaceId: string, runId: string, rawOps: unknown): DreamRunRecord;
+    getMemoryDreamInput(workspaceId: string, runId: string): MemoryDreamInput;
     listMemoryDreamRuns(workspaceId: string, limit?: number): DreamRunRecord[];
     revertMemoryDream(workspaceId: string, runId: string): DreamRunRecord;
     runMemoryDream(workspaceId: string): Promise<DreamRunRecord>;

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

@@ -1,6 +1,54 @@
+import { buildDreamPrompt, DREAM_PROMPT_MEMORY_LIMIT, DREAM_PROMPT_MESSAGE_LIMIT, } from './team-memory-dream-prompt.js';
+import { DREAM_STALE_ERROR, DreamRunNotFoundError, DreamRunValidationError, } from './team-memory-dream-store.js';
+const shouldExportStaleRun = (run) => run.status === 'failed' && run.error === DREAM_STALE_ERROR;
 export const createRuntimeStoreDreamMethods = (services) => ({
+    applyMemoryDreamRun(workspaceId, runId, rawOps) {
+        const existing = services.teamMemoryDreamStore.getRun(runId);
+        if (!existing || existing.workspaceId !== workspaceId) {
+            throw new DreamRunNotFoundError(workspaceId, runId);
+        }
+        if (existing.status !== 'running') {
+            if (shouldExportStaleRun(existing))
+                services.teamMemoryExport.schedule(workspaceId);
+            throw new DreamRunValidationError('Dream run is no longer running');
+        }
+        try {
+            const run = services.teamMemoryDreamStore.applyAndCompleteRun(workspaceId, runId, rawOps);
+            services.teamMemoryExport.schedule(workspaceId);
+            return run;
+        }
+        catch (error) {
+            services.teamMemoryExport.schedule(workspaceId);
+            throw error;
+        }
+    },
+    getMemoryDreamInput(workspaceId, runId) {
+        const run = services.teamMemoryDreamStore.getRun(runId);
+        if (!run || run.workspaceId !== workspaceId)
+            throw new DreamRunNotFoundError(workspaceId, runId);
+        if (run.status !== 'running') {
+            if (shouldExportStaleRun(run))
+                services.teamMemoryExport.schedule(workspaceId);
+            throw new DreamRunValidationError('Dream run is no longer running');
+        }
+        const messages = services.teamMemoryDreamStore
+            .listInputMessages(workspaceId, run.inputSeqFrom, run.inputSeqTo)
+            .slice(-DREAM_PROMPT_MESSAGE_LIMIT);
+        const memories = services.teamMemoryStore
+            .listAllEntries(workspaceId)
+            .filter((memory) => memory.status === 'active' && memory.updatedAt <= run.startedAt)
+            .slice(0, DREAM_PROMPT_MEMORY_LIMIT);
+        return {
+            prompt: buildDreamPrompt({ memories, messages, workspaceId }),
+            run,
+        };
+    },
     listMemoryDreamRuns(workspaceId, limit) {
-        return services.teamMemoryDreamStore.listRuns(workspaceId, limit);
+        const runs = services.teamMemoryDreamStore.listRuns(workspaceId, limit);
+        if (runs.some(shouldExportStaleRun)) {
+            services.teamMemoryExport.schedule(workspaceId);
+        }
+        return runs;
     },
     revertMemoryDream(workspaceId, runId) {
         const run = services.teamMemoryDreamStore.revertRun(workspaceId, runId);

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

@@ -4,12 +4,14 @@ 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 { createProtocolEventStats } from './protocol-event-stats.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 { createSentinelHeartbeatService } from './sentinel-heartbeat.js';
 import { createSettingsStore } from './settings-store.js';
 import { createTasksFileService } from './tasks-file.js';
 import { createTasksFileWatcher } from './tasks-file-watcher.js';
@@ -29,6 +31,7 @@ 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';
+import { createWorkspaceUploadStore } from './workspace-upload-store.js';
 export interface RuntimeStoreServices {
     agentRunStore: ReturnType<typeof createAgentRunStore>;
     agentRuntime: ReturnType<typeof createAgentRuntime>;
@@ -46,6 +49,8 @@ export interface RuntimeStoreServices {
     tasksFileService: ReturnType<typeof createTasksFileService>;
     teamMemoryDreamRunner: ReturnType<typeof createTeamMemoryDreamRunner>;
     teamMemoryDreamScheduler: ReturnType<typeof createTeamMemoryDreamScheduler>;
+    sentinelHeartbeat: ReturnType<typeof createSentinelHeartbeatService>;
+    protocolEventStats: ReturnType<typeof createProtocolEventStats>;
     teamMemoryDreamStore: ReturnType<typeof createTeamMemoryDreamStore>;
     teamMemoryStore: ReturnType<typeof createTeamMemoryStore>;
     teamMemoryExport: ReturnType<typeof createTeamMemoryExportService>;
@@ -59,6 +64,8 @@ export interface RuntimeStoreServices {
     workflowRunStore: ReturnType<typeof createWorkflowRunStore>;
     workflowScheduleStore: ReturnType<typeof createWorkflowScheduleStore>;
     workspaceStore: ReturnType<typeof createWorkspaceStore>;
+    workspaceUploadStore: ReturnType<typeof createWorkspaceUploadStore>;
+    workspaceUploadStorageCleanup: () => void;
 }
 interface CreateRuntimeStoreServicesOptions {
     agentManager?: AgentManager;