hivehq 2.0.0

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

@@ -0,0 +1,411 @@
+import { createAgentRunStore } from './agent-run-store.js';
+import { createAgentRuntime } from './agent-runtime.js';
+import { createAgentSessionStore } from './agent-session-store.js';
+import { createDispatchLedgerStore } from './dispatch-ledger-store.js';
+import { readFeatureFlags } from './feature-flags.js';
+import { createMessageLogStore } from './message-log-store.js';
+import { seedOrchestratorLaunchConfig } from './orchestrator-launch.js';
+import { createRemoteAuditStore } from './remote-audit-store.js';
+import { REMOTE_DAEMON_ID_KEY, REMOTE_GATEWAY_URL_KEY } from './remote-config-keys.js';
+import { createPersistentDeviceSessionProvider, createRemoteDeviceStore, } from './remote-device-store.js';
+import { createRemotePairing } from './remote-pairing.js';
+import { createReportOutboxStore } from './report-outbox-store.js';
+import { openRuntimeDatabase } from './runtime-database.js';
+import { buildRuntimeRestartPolicy } from './runtime-restart-policy.js';
+import { createSettingsStore } from './settings-store.js';
+import { createTasksFileService } from './tasks-file.js';
+import { createTasksFileWatcher } from './tasks-file-watcher.js';
+import { createWorkspaceMemoryDigestProvider } from './team-memory-digest.js';
+import { createTeamMemoryDreamRunner, defaultDreamCliCommand, dreamCliCommandForLaunchCommand, } from './team-memory-dream-runner.js';
+import { createTeamMemoryDreamScheduler } from './team-memory-dream-scheduler.js';
+import { createTeamMemoryDreamStore } from './team-memory-dream-store.js';
+import { createTeamMemoryExportService, MEMORY_EXPORT_DREAM_CHANGELOG_LIMIT, } 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 { resolveTerminalInputProfile } from './terminal-input-profile.js';
+import { createUiAuth } from './ui-auth.js';
+import { createWebhookNotifier, WEBHOOK_URL_KEY } from './webhook-notifier.js';
+import { createWorkerOutputTracker } from './worker-output-tracker.js';
+import { readWorkflowCliPolicy, WORKFLOW_CLI_POLICY_KEY } from './workflow-cli-policy.js';
+import { createWorkflowDispatchAwaiter, } 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';
+import { getOrchestratorId } from './workspace-store-support.js';
+const notifyTasksUpdated = (callbacks, workspaceId, content) => {
+    for (const callback of callbacks) {
+        callback(workspaceId, content);
+    }
+};
+export const logTasksFileWatchStartError = (workspaceId, error) => {
+    console.error(`[hive] failed to start tasks watcher for workspace ${workspaceId}`, error);
+};
+export const createRuntimeStoreServices = (options = {}) => {
+    const db = openRuntimeDatabase(options.dataDir);
+    const messageLogStore = createMessageLogStore(db);
+    const dispatchLedgerStore = createDispatchLedgerStore(db);
+    const teamMemoryStore = createTeamMemoryStore(db);
+    const teamMemoryDreamStore = createTeamMemoryDreamStore(db);
+    const teamRecallStore = createTeamRecallStore(db);
+    const reportOutbox = createReportOutboxStore(db);
+    const workflowDispatchAwaiter = createWorkflowDispatchAwaiter();
+    const workflowRunStore = createWorkflowRunStore(db);
+    const workflowRunLogStore = createWorkflowRunLogStore(db);
+    const workflowScheduleStore = createWorkflowScheduleStore(db);
+    const agentRunStore = createAgentRunStore(db);
+    const agentSessionStore = createAgentSessionStore(db);
+    const settings = createSettingsStore(db);
+    const getFlags = () => readFeatureFlags(settings);
+    const memoryDigestProvider = createWorkspaceMemoryDigestProvider({
+        memoryStore: teamMemoryStore,
+        settings,
+    });
+    const memoryInjection = {
+        buildDigest: memoryDigestProvider.buildDigest,
+        buildDispatchDigest: memoryDigestProvider.buildDispatchDigest,
+        deleteInjections: teamMemoryStore.deleteInjections,
+        logInjections: teamMemoryStore.logInjections,
+    };
+    const webhookNotifier = createWebhookNotifier({
+        getUrl: () => settings.getAppState(WEBHOOK_URL_KEY)?.value ?? null,
+    });
+    const tasksFileService = createTasksFileService();
+    const tasksFileWatchCallbacks = new Set();
+    const tasksFileWatcher = createTasksFileWatcher({
+        onTasksUpdated: (workspaceId, content) => {
+            notifyTasksUpdated(tasksFileWatchCallbacks, workspaceId, content);
+        },
+        getWorkflowCliPolicy: () => readWorkflowCliPolicy(settings.getAppState(WORKFLOW_CLI_POLICY_KEY)?.value ?? null),
+        getFlags,
+    });
+    const uiAuth = createUiAuth();
+    const remoteAuditStore = createRemoteAuditStore(db);
+    // M4: the live runtime uses the PERSISTENT provider backed by the device store (M3's
+    // InMemoryDeviceSessionProvider stays test-only). A device row exists only after a desktop confirm,
+    // so this provider serves nothing until then; a revoke drops it from get()/candidates() at once.
+    const remoteDeviceStore = createRemoteDeviceStore(db);
+    const remoteDeviceSessions = createPersistentDeviceSessionProvider(remoteDeviceStore);
+    const remotePairing = createRemotePairing({
+        deviceStore: remoteDeviceStore,
+        audit: remoteAuditStore,
+        getGatewayUrl: () => settings.getAppState(REMOTE_GATEWAY_URL_KEY)?.value ?? null,
+        getDaemonId: () => settings.getAppState(REMOTE_DAEMON_ID_KEY)?.value ?? null,
+    });
+    const shellRuntime = createWorkspaceShellRuntime(options.agentManager);
+    agentRunStore.markUnfinishedRunsStale();
+    workflowRunStore.markUnfinishedRunsInterrupted();
+    const workspaceStore = createWorkspaceStore(db, dispatchLedgerStore.listOpenDispatchKinds());
+    const teamMemoryExport = createTeamMemoryExportService({
+        getWorkspacePath: (workspaceId) => workspaceStore.getWorkspaceSnapshot(workspaceId).summary.path,
+        listDreamRuns: (workspaceId) => teamMemoryDreamStore.listRuns(workspaceId, MEMORY_EXPORT_DREAM_CHANGELOG_LIMIT),
+        listEntries: teamMemoryStore.listExportEntries,
+    });
+    const startExistingWorkspaceWatches = () => {
+        for (const workspace of workspaceStore.listWorkspaces()) {
+            void tasksFileWatcher
+                .start(workspace.id, workspace.path)
+                .catch((error) => logTasksFileWatchStartError(workspace.id, error));
+        }
+    };
+    const restartPolicy = buildRuntimeRestartPolicy({
+        agentRunStore,
+        messageLogStore,
+        memoryInjection,
+        tasksFileService,
+        workspaceStore,
+        getFlags,
+    });
+    const workerOutputTracker = options.agentManager
+        ? createWorkerOutputTracker(options.agentManager.getOutputBus())
+        : null;
+    const agentRuntime = createAgentRuntime(options.agentManager, agentRunStore, agentSessionStore, settings.getCommandPreset, (workspaceId, agentId) => {
+        workerOutputTracker?.detach(workspaceId, agentId);
+        if (!workspaceStore.hasAgent(workspaceId, agentId))
+            return;
+        workspaceStore.markAgentStopped(workspaceId, agentId);
+        // TIER 1 #1 — if the exiting worker had any open workflow dispatches,
+        // tell the workflow awaiter so the runner's `awaitReport` rejects
+        // immediately instead of hanging until DEFAULT_TIMEOUT_MS (10 min).
+        // This is the only signal the runtime has that an ephemeral
+        // workflow worker died without calling `team report`.
+        const openWorkflowDispatches = dispatchLedgerStore.listOpenWorkflowDispatchesForWorker(workspaceId, agentId);
+        for (const { dispatchId } of openWorkflowDispatches) {
+            try {
+                const cancelled = dispatchLedgerStore.markCancelled({
+                    dispatchId,
+                    reason: 'worker PTY exited before report',
+                    workspaceId,
+                });
+                if (!cancelled)
+                    continue;
+                try {
+                    workspaceStore.markTaskCancelled(workspaceId, agentId);
+                }
+                catch (error) {
+                    console.error('[hive] onAgentExit.markTaskCancelled failed', dispatchId, error);
+                }
+                workflowDispatchAwaiter.notifyCancel(dispatchId, 'worker PTY exited before report');
+            }
+            catch (error) {
+                console.error('[hive] onAgentExit.markCancelled failed', dispatchId, error);
+            }
+        }
+        // Cascade: when the orchestrator's PTY exits, dismiss the ephemeral
+        // workers it spawned via `team spawn` (spec §6.3). Workflow-spawned
+        // workers are owned by the runner, not the orchestrator.
+        if (agentId === getOrchestratorId(workspaceId)) {
+            const children = workspaceStore
+                .getWorkspaceSnapshot(workspaceId)
+                .agents.filter((agent) => agent.ephemeral === true && agent.spawnedBy === 'orchestrator');
+            for (const child of children)
+                removeWorkerCompletely(workspaceId, child.id);
+        }
+    }, restartPolicy, (workspaceId, agentId) => workspaceStore.getAgent(workspaceId, agentId), getFlags, memoryInjection);
+    const teamMemoryDreamRunner = createTeamMemoryDreamRunner({
+        dreamStore: teamMemoryDreamStore,
+        getDreamCliCommand: (workspaceId) => {
+            seedOrchestratorLaunchConfig(agentRuntime, settings, workspaceId);
+            const config = agentRuntime.peekAgentLaunchConfig(workspaceId, getOrchestratorId(workspaceId));
+            return config?.command
+                ? dreamCliCommandForLaunchCommand(config.command)
+                : defaultDreamCliCommand();
+        },
+        getWorkspacePath: (workspaceId) => workspaceStore.getWorkspaceSnapshot(workspaceId).summary.path,
+        memoryStore: teamMemoryStore,
+        scheduleExport: teamMemoryExport.schedule,
+    });
+    const teamMemoryDreamScheduler = createTeamMemoryDreamScheduler({
+        getScheduleState: teamMemoryDreamStore.getScheduleState,
+        getWorkspaceSnapshot: (workspaceId) => workspaceStore.getWorkspaceSnapshot(workspaceId),
+        listWorkspaces: workspaceStore.listWorkspaces,
+        runScheduled: teamMemoryDreamRunner.runScheduled,
+        settings,
+    });
+    teamMemoryDreamScheduler.start();
+    // Mirrors runtime-store.deleteWorker (drop dispatches + worker row
+    // transactionally → drop launch config → stop run). Hoisted `function` so the
+    // onAgentExit closure above can reference it; only invoked at runtime, after
+    // agentRuntime is assigned.
+    function removeWorkerCompletely(workspaceId, workerId) {
+        const activeRun = agentRuntime.getActiveRunByAgentId(workspaceId, workerId);
+        db.transaction(() => {
+            dispatchLedgerStore.deleteWorkerDispatches(workspaceId, workerId);
+            workspaceStore.deleteWorker(workspaceId, workerId);
+        })();
+        agentRuntime.deleteAgentLaunchConfig(workspaceId, workerId);
+        if (activeRun)
+            agentRuntime.stopAgentRun(activeRun.runId);
+    }
+    // Boot cleanup: after a runtime restart every ephemeral worker is an orphan
+    // (its spawner — a workflow run or an orchestrator PTY — is gone). Remove
+    // them so they don't accumulate (spec §6.3).
+    const cleanupOrphanEphemeralWorkers = () => {
+        for (const workspace of workspaceStore.listWorkspaces()) {
+            const ephemeral = workspaceStore
+                .getWorkspaceSnapshot(workspace.id)
+                .agents.filter((agent) => agent.ephemeral === true);
+            for (const agent of ephemeral)
+                removeWorkerCompletely(workspace.id, agent.id);
+        }
+    };
+    const teamOps = createTeamOperations({
+        agentRuntime,
+        createDispatch: dispatchLedgerStore.createDispatch,
+        deleteDispatch: dispatchLedgerStore.deleteDispatch,
+        deleteMessage: messageLogStore.deleteMessage,
+        findOpenDispatch: dispatchLedgerStore.findOpenDispatch,
+        findOpenDispatchById: dispatchLedgerStore.findOpenDispatchById,
+        insertMessage: messageLogStore.insertMessage,
+        markDispatchCancelled: dispatchLedgerStore.markCancelled,
+        markDispatchReportedByWorker: dispatchLedgerStore.markReportedByWorker,
+        markDispatchSubmitted: dispatchLedgerStore.markSubmitted,
+        reportOutbox,
+        notifyWebhook: webhookNotifier.notify,
+        workflowDispatchAwaiter,
+        workspaceStore,
+        dismissEphemeralWorker: (workspaceId, workerId) => removeWorkerCompletely(workspaceId, workerId),
+    });
+    cleanupOrphanEphemeralWorkers();
+    startExistingWorkspaceWatches();
+    return {
+        agentRunStore,
+        agentRuntime,
+        db,
+        dispatchLedgerStore,
+        messageLogStore,
+        remoteAuditStore,
+        remoteDeviceSessions,
+        remoteDeviceStore,
+        remotePairing,
+        settings,
+        shellRuntime,
+        tasksFileWatcher,
+        tasksFileWatchCallbacks,
+        tasksFileService,
+        teamMemoryDreamRunner,
+        teamMemoryDreamScheduler,
+        teamMemoryDreamStore,
+        teamMemoryExport,
+        teamMemoryStore,
+        teamRecallStore,
+        teamOps,
+        uiAuth,
+        webhookNotifier,
+        workerOutputTracker,
+        workflowDispatchAwaiter,
+        workflowRunLogStore,
+        workflowRunStore,
+        workflowScheduleStore,
+        workspaceStore,
+    };
+};
+export const createRuntimeStoreLifecycle = ({ agentManager, services, }) => {
+    const startAgent = async (workspaceId, agentId, input) => {
+        services.workspaceStore.getAgent(workspaceId, agentId);
+        services.workspaceStore.markAgentStarted(workspaceId, agentId);
+        try {
+            const run = await services.agentRuntime.startAgent(services.workspaceStore.getWorkspaceSnapshot(workspaceId).summary, agentId, input);
+            if (run.status === 'error') {
+                services.workspaceStore.markAgentStopped(workspaceId, agentId);
+            }
+            else {
+                services.workerOutputTracker?.attach(workspaceId, agentId, run.runId, run.output);
+            }
+            return run;
+        }
+        catch (error) {
+            services.workspaceStore.markAgentStopped(workspaceId, agentId);
+            throw error;
+        }
+    };
+    const autostartConfiguredAgents = async (input) => {
+        if (!agentManager)
+            return [];
+        const starts = services.workspaceStore.listWorkspaces().flatMap((workspace) => {
+            seedOrchestratorLaunchConfig(services.agentRuntime, services.settings, workspace.id);
+            return services.workspaceStore
+                .getWorkspaceSnapshot(workspace.id)
+                .agents.filter((agent) => !services.agentRuntime.getActiveRunByAgentId(workspace.id, agent.id) &&
+                services.agentRuntime.peekAgentLaunchConfig(workspace.id, agent.id))
+                .map(async (agent) => {
+                try {
+                    const run = await startAgent(workspace.id, agent.id, input);
+                    return {
+                        agent_id: agent.id,
+                        error: null,
+                        ok: true,
+                        run_id: run.runId,
+                        workspace_id: workspace.id,
+                    };
+                }
+                catch (error) {
+                    return {
+                        agent_id: agent.id,
+                        error: error instanceof Error ? error.message : String(error),
+                        ok: false,
+                        run_id: null,
+                        workspace_id: workspace.id,
+                    };
+                }
+            });
+        });
+        return Promise.all(starts);
+    };
+    return {
+        close: async () => {
+            // Fail in-flight workflow awaiters BEFORE their workers vanish, so the
+            // runner's `await agent(...)` rejects with a clear shutdown error
+            // instead of hanging on a Promise that can never resolve.
+            services.workflowDispatchAwaiter.cancelAll('runtime closing');
+            services.shellRuntime.close();
+            await services.teamMemoryExport.close();
+            await services.agentRuntime.close();
+            await services.tasksFileWatcher.close();
+            services.workerOutputTracker?.closeAll();
+            services.agentRunStore.close?.();
+            services.db.close();
+        },
+        configureAgentLaunch: (workspaceId, agentId, input) => {
+            services.workspaceStore.getAgent(workspaceId, agentId);
+            services.agentRuntime.configureAgentLaunch(workspaceId, agentId, input);
+        },
+        peekAgentLaunchConfig: (workspaceId, agentId) => services.agentRuntime.peekAgentLaunchConfig(workspaceId, agentId),
+        deleteWorkspaceShell: (workspaceId) => {
+            services.shellRuntime.deleteWorkspace(workspaceId);
+        },
+        closeWorkspaceShell: (workspaceId, runId) => services.shellRuntime.closeRun(workspaceId, runId),
+        getLiveRun: (runId) => services.shellRuntime.getLiveRun(runId) ?? services.agentRuntime.getLiveRun(runId),
+        getPtyOutputBus: () => {
+            if (!agentManager)
+                throw new Error('Agent manager is required for PTY output subscriptions');
+            return agentManager.getOutputBus();
+        },
+        listTerminalRuns: (workspaceId) => [
+            ...services.workspaceStore.getWorkspaceSnapshot(workspaceId).agents.flatMap((agent) => {
+                const run = services.agentRuntime.getActiveRunByAgentId(workspaceId, agent.id);
+                if (!run)
+                    return [];
+                const launchConfig = services.agentRuntime.peekAgentLaunchConfig(workspaceId, agent.id);
+                return [
+                    {
+                        agent_id: agent.id,
+                        agent_name: agent.name,
+                        run_id: run.runId,
+                        status: run.status,
+                        terminal_input_profile: resolveTerminalInputProfile(launchConfig),
+                    },
+                ];
+            }),
+            ...services.shellRuntime.listTerminalRuns(workspaceId),
+        ],
+        startAgent,
+        startWorkspaceShell: (workspaceId) => services.shellRuntime.start(services.workspaceStore.getWorkspaceSnapshot(workspaceId).summary),
+        autostartConfiguredAgents,
+        registerTasksListener: (listener) => {
+            services.tasksFileWatchCallbacks.add(listener);
+            return () => {
+                services.tasksFileWatchCallbacks.delete(listener);
+            };
+        },
+        startWorkspaceWatch: async (workspaceId) => {
+            const workspace = services.workspaceStore.getWorkspaceSnapshot(workspaceId);
+            await services.tasksFileWatcher.start(workspaceId, workspace.summary.path);
+        },
+        writeRunInput: (runId, input) => {
+            if (!agentManager)
+                throw new Error('Agent manager is required for PTY stdin writes');
+            if (services.shellRuntime.hasRun(runId)) {
+                services.shellRuntime.writeInput(runId, input);
+                return;
+            }
+            agentManager.writeInput(runId, input);
+        },
+        pauseTerminalRun: (runId) => {
+            if (services.shellRuntime.hasRun(runId))
+                services.shellRuntime.pauseRun(runId);
+            else
+                services.agentRuntime.pauseRun(runId);
+        },
+        resizeTerminalRun: (runId, cols, rows) => {
+            if (services.shellRuntime.hasRun(runId))
+                services.shellRuntime.resizeRun(runId, cols, rows);
+            else
+                services.agentRuntime.resizeAgentRun(runId, cols, rows);
+        },
+        resumeTerminalRun: (runId) => {
+            if (services.shellRuntime.hasRun(runId))
+                services.shellRuntime.resumeRun(runId);
+            else
+                services.agentRuntime.resumeRun(runId);
+        },
+        stopTerminalRun: (runId) => {
+            if (services.shellRuntime.hasRun(runId))
+                services.shellRuntime.stopRun(runId);
+            else
+                services.agentRuntime.stopAgentRun(runId);
+        },
+    };
+};

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

@@ -0,0 +1,33 @@
+import type { AddMemoryEntryInput, LogMemoryInjectionsInput, MemoryEntryWithSources, MemoryInjectionWithMemory, MemoryListOptions, MemorySearchOptions, MemorySearchResult } from './team-memory-store.js';
+interface RuntimeStoreMemoryServices {
+    teamMemoryExport: {
+        schedule: (workspaceId: string) => void;
+    };
+    teamMemoryStore: {
+        addEntry: (input: AddMemoryEntryInput) => MemoryEntryWithSources;
+        approveCandidate: (workspaceId: string, memoryId: string) => MemoryEntryWithSources;
+        archiveEntry: (workspaceId: string, memoryId: string) => MemoryEntryWithSources;
+        getEntryWithSources: (workspaceId: string, memoryId: string) => MemoryEntryWithSources | undefined;
+        listEntries: (workspaceId: string, options?: MemoryListOptions) => MemoryEntryWithSources[];
+        listInjectionsForDispatch: (workspaceId: string, dispatchId: string) => MemoryInjectionWithMemory[];
+        logInjections: (input: LogMemoryInjectionsInput) => string[];
+        rejectCandidate: (workspaceId: string, memoryId: string) => MemoryEntryWithSources;
+        searchEntries: (workspaceId: string, query: string, options?: MemorySearchOptions) => MemorySearchResult[];
+        setDisabled: (workspaceId: string, memoryId: string, disabled: boolean) => MemoryEntryWithSources;
+        setPinned: (workspaceId: string, memoryId: string, pinned: boolean) => MemoryEntryWithSources;
+    };
+}
+export declare const createRuntimeStoreMemoryMethods: (services: RuntimeStoreMemoryServices) => {
+    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;
+};
+export {};

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

@@ -0,0 +1,37 @@
+export const createRuntimeStoreMemoryMethods = (services) => ({
+    addMemoryEntry(input) {
+        const memory = services.teamMemoryStore.addEntry(input);
+        services.teamMemoryExport.schedule(input.workspaceId);
+        return memory;
+    },
+    approveMemoryCandidate(workspaceId, memoryId) {
+        const memory = services.teamMemoryStore.approveCandidate(workspaceId, memoryId);
+        services.teamMemoryExport.schedule(workspaceId);
+        return memory;
+    },
+    archiveMemoryEntry(workspaceId, memoryId) {
+        const memory = services.teamMemoryStore.archiveEntry(workspaceId, memoryId);
+        services.teamMemoryExport.schedule(workspaceId);
+        return memory;
+    },
+    getMemoryEntry: (workspaceId, memoryId) => services.teamMemoryStore.getEntryWithSources(workspaceId, memoryId),
+    listMemoryEntries: (workspaceId, options) => services.teamMemoryStore.listEntries(workspaceId, options),
+    listMemoryInjectionsForDispatch: (workspaceId, dispatchId) => services.teamMemoryStore.listInjectionsForDispatch(workspaceId, dispatchId),
+    logMemoryInjections: (input) => services.teamMemoryStore.logInjections(input),
+    rejectMemoryCandidate(workspaceId, memoryId) {
+        const memory = services.teamMemoryStore.rejectCandidate(workspaceId, memoryId);
+        services.teamMemoryExport.schedule(workspaceId);
+        return memory;
+    },
+    searchMemoryEntries: (workspaceId, query, options) => services.teamMemoryStore.searchEntries(workspaceId, query, options),
+    setMemoryDisabled(workspaceId, memoryId, disabled) {
+        const memory = services.teamMemoryStore.setDisabled(workspaceId, memoryId, disabled);
+        services.teamMemoryExport.schedule(workspaceId);
+        return memory;
+    },
+    setMemoryPinned(workspaceId, memoryId, pinned) {
+        const memory = services.teamMemoryStore.setPinned(workspaceId, memoryId, pinned);
+        services.teamMemoryExport.schedule(workspaceId);
+        return memory;
+    },
+});

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

@@ -0,0 +1,5 @@
+import type { RuntimeStore } from './runtime-store-contract.js';
+import type { RuntimeStoreServices } from './runtime-store-helpers.js';
+type RuntimeStoreRemoteMethods = Pick<RuntimeStore, 'authorizeRemoteTunnelRequest' | 'bindRemoteTunnel' | 'confirmRemotePairing' | 'getRemoteAuditStore' | 'getRemoteDeviceSessions' | 'getRemoteDeviceStore' | 'getRemotePairing' | 'getRemoteTunnelSecret' | 'getRemoteTunnelStatus' | 'revokeRemoteDevice' | 'setRemoteEnabled' | 'setRemoteTunnelStatus'>;
+export declare const createRuntimeStoreRemoteMethods: (services: RuntimeStoreServices) => RuntimeStoreRemoteMethods;
+export {};

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

@@ -0,0 +1,45 @@
+import { REMOTE_ENABLED_KEY } from './remote-config-keys.js';
+export const createRuntimeStoreRemoteMethods = (services) => {
+    // Remote tunnel handle (M4). bindRemoteTunnel sets it in hive.ts after the tunnel is constructed;
+    // a runtime that never builds a tunnel leaves it null and the revoke closed loop still rejects new
+    // streams via the persistent provider.
+    let remoteTunnel = null;
+    let remoteTunnelStatus = 'disabled';
+    return {
+        authorizeRemoteTunnelRequest: (request) => services.uiAuth.isTunnelRequest(request),
+        getRemoteTunnelSecret: () => services.uiAuth.getTunnelSecret(),
+        getRemoteAuditStore: () => services.remoteAuditStore,
+        getRemoteDeviceSessions: () => services.remoteDeviceSessions,
+        getRemotePairing: () => services.remotePairing,
+        confirmRemotePairing: async (pairingId, name) => {
+            // D3: the tunnel driver owns the full confirm sequence (local row -> gateway /pair/confirm ->
+            // `confirmed` to the phone). If no tunnel is bound, fall back to local-only confirm.
+            if (remoteTunnel)
+                return remoteTunnel.confirmPairing(pairingId, name);
+            return services.remotePairing.confirmPairing(pairingId, name === undefined ? undefined : { name });
+        },
+        getRemoteDeviceStore: () => services.remoteDeviceStore,
+        getRemoteTunnelStatus: () => remoteTunnelStatus,
+        setRemoteTunnelStatus: (status) => {
+            remoteTunnelStatus = status;
+        },
+        bindRemoteTunnel: (tunnel) => {
+            remoteTunnel = tunnel;
+        },
+        setRemoteEnabled: (enabled) => {
+            services.settings.setAppState(REMOTE_ENABLED_KEY, enabled ? 'true' : 'false');
+            // Reconcile the outbound socket against the new flag. No-op when no tunnel is bound.
+            remoteTunnel?.refresh();
+        },
+        revokeRemoteDevice: (deviceId) => {
+            // (1) Persistent provider drops the session at once; (2) live streams are closed best-effort;
+            // (3) audit one revoke row for actual state changes.
+            const revoked = services.remoteDeviceStore.revoke(deviceId);
+            remoteTunnel?.closeDevice(deviceId, 'revoked');
+            if (revoked) {
+                services.remoteAuditStore.enqueue({ action: 'revoke', deviceId, result: 'ok' });
+            }
+            return revoked;
+        },
+    };
+};

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

@@ -0,0 +1,6 @@
+import type { RuntimeStore } from './runtime-store-contract.js';
+import type { RuntimeStoreServices } from './runtime-store-helpers.js';
+export declare const createRuntimeStoreWorkflowRuntime: (services: RuntimeStoreServices, store: RuntimeStore) => {
+    runner: import("./workflow-runner.js").WorkflowRunner;
+    scheduler: import("./workflow-scheduler.js").WorkflowScheduler;
+};

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

@@ -0,0 +1,108 @@
+import { readWorkflowCliPolicy, WORKFLOW_CLI_POLICY_KEY } from './workflow-cli-policy.js';
+import { readWorkflowEnabled, WORKFLOW_ENABLED_KEY } from './workflow-feature.js';
+import { createWorkflowRunner } from './workflow-runner.js';
+import { createWorkflowScheduler } from './workflow-scheduler.js';
+export const createRuntimeStoreWorkflowRuntime = (services, store) => {
+    const runner = createWorkflowRunner({
+        awaiter: services.workflowDispatchAwaiter,
+        workflowRunStore: services.workflowRunStore,
+        dispatchPort: {
+            listOpenDispatchIdsForRun: (runId) => services.dispatchLedgerStore.listOpenDispatchIdsForRun(runId),
+        },
+        resolveWorkspacePath: (workspaceId) => services.workspaceStore.getWorkspaceSnapshot(workspaceId).summary.path,
+        logStore: {
+            append: (runId, message, ts) => services.workflowRunLogStore.append(runId, message, ts),
+        },
+        getWorkflowCliPolicy: () => readWorkflowCliPolicy(services.settings.getAppState(WORKFLOW_CLI_POLICY_KEY)?.value ?? null),
+        roleTemplateResolver: {
+            findByName: (name) => {
+                const t = services.settings.findRoleTemplateByName(name);
+                if (!t)
+                    return undefined;
+                return {
+                    name: t.name,
+                    roleType: t.roleType,
+                    defaultCommand: t.defaultCommand,
+                    defaultArgs: t.defaultArgs,
+                };
+            },
+        },
+        onRunFinished: ({ runId, triggeredByAgentId, finalRecord }) => {
+            const workspaceId = finalRecord.workspaceId;
+            const dispatches = services.dispatchLedgerStore.listWorkflowRunDispatches(runId);
+            const errorLine = finalRecord.error ? `\nerror: ${finalRecord.error}` : '';
+            const dispatchSummary = dispatches.length === 0
+                ? '\n(no agent() calls in this run)'
+                : '\n' +
+                    dispatches
+                        .map((d) => {
+                        const reply = d.reportText
+                            ? d.reportText.length > 200
+                                ? `${d.reportText.slice(0, 197).trim()}...`
+                                : d.reportText.trim()
+                            : `(no report; status=${d.status})`;
+                        return `  #${d.stepIndex ?? '?'} -> ${reply}`;
+                    })
+                        .join('\n');
+            const resultBlock = (() => {
+                if (finalRecord.result === null || finalRecord.result === undefined)
+                    return '';
+                const serialized = typeof finalRecord.result === 'string'
+                    ? finalRecord.result
+                    : JSON.stringify(finalRecord.result, null, 2);
+                const truncated = serialized.length > 4000
+                    ? `${serialized.slice(0, 4000)}\n...(truncated; ${serialized.length - 4000} more chars)`
+                    : serialized;
+                return `\nResult (workflow return value):\n${truncated}`;
+            })();
+            const logTail = services.workflowRunLogStore.tailForRun(runId, 8);
+            const logBlock = logTail.length === 0
+                ? ''
+                : `\nNarrator (last ${logTail.length} log line${logTail.length === 1 ? '' : 's'}):\n` +
+                    logTail.map((line) => `  - ${line}`).join('\n');
+            const payload = '<hive-system-reminder>\n' +
+                `Hive workflow \`${finalRecord.name}\` finished: status=${finalRecord.status}` +
+                ` (run_id=${runId}, ${dispatches.length} agent call${dispatches.length === 1 ? '' : 's'}).` +
+                errorLine +
+                resultBlock +
+                logBlock +
+                dispatchSummary +
+                '\nThis result is what you should synthesize back to the user. ' +
+                'Per-agent transcripts are available via `team workflow show ' +
+                runId +
+                '` if needed.\n' +
+                '</hive-system-reminder>\n';
+            try {
+                services.agentRuntime.writeSystemMessageToAgent(workspaceId, triggeredByAgentId, payload);
+            }
+            catch (error) {
+                console.error('[hive] workflow.notifyTrigger failed', error);
+            }
+            // Outbound completion webhook (best-effort) so the user is pinged when a
+            // long fan-out finishes without watching the drawer.
+            services.webhookNotifier.notify({
+                type: 'workflow_finished',
+                workspaceId,
+                summary: `${finalRecord.name}: ${finalRecord.status}${finalRecord.error ? ` — ${finalRecord.error}` : ''}`,
+                at: Date.now(),
+            });
+        },
+        store: {
+            addWorkerWithLaunch: (ws, input, launch) => store.addWorkerWithLaunch(ws, input, launch),
+            deleteWorker: (ws, workerId) => store.deleteWorker(ws, workerId),
+            dispatchTaskByWorkerName: async (ws, name, text, input) => {
+                const dispatch = await store.dispatchTaskByWorkerName(ws, name, text, input);
+                return { id: dispatch.id };
+            },
+            startAgent: (ws, agentId, input) => store.startAgent(ws, agentId, input),
+        },
+    });
+    const scheduler = createWorkflowScheduler({
+        schedules: services.workflowScheduleStore,
+        startWorkflow: (input) => store.startWorkflow(input),
+        workspaceExists: (workspaceId) => services.workspaceStore.hasWorkspace(workspaceId),
+        isWorkflowEnabled: () => readWorkflowEnabled(services.settings.getAppState(WORKFLOW_ENABLED_KEY)?.value ?? null),
+    });
+    scheduler.start();
+    return { runner, scheduler };
+};

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

@@ -0,0 +1,4 @@
+import type { RuntimeStore, RuntimeStoreOptions } from './runtime-store-contract.js';
+import type { WorkflowRunRecord } from './workflow-run-store.js';
+export type { RuntimeStore, WorkflowRunRecord };
+export declare const createRuntimeStore: (options?: RuntimeStoreOptions) => RuntimeStore;