@tt-a1i/hive 1.4.4 → 1.6.0

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

@@ -0,0 +1,125 @@
+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 { SettingsStore } from './settings-store.js';
+import type { CancelTaskInput, DispatchTaskInput, ReportTaskInput, ReportTaskResult, StatusTaskInput } from './team-operations.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[];
+    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;
+    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-helpers.d.ts

@@ -11,7 +11,12 @@ import { createTasksFileService } from './tasks-file.js';
 import { createTasksFileWatcher } from './tasks-file-watcher.js';
 import { createTeamOperations } from './team-operations.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 {
@@ -27,7 +32,12 @@ export interface RuntimeStoreServices {
     tasksFileService: ReturnType<typeof createTasksFileService>;
     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 {
@@ -38,6 +48,7 @@ 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>;

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

@@ -2,8 +2,10 @@ 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 { 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';
@@ -12,35 +14,59 @@ import { createTasksFileWatcher } from './tasks-file-watcher.js';
 import { createTeamOperations } from './team-operations.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 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 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 shellRuntime = createWorkspaceShellRuntime(options.agentManager);
     agentRunStore.markUnfinishedRunsStale();
+    workflowRunStore.markUnfinishedRunsInterrupted();
     const workspaceStore = createWorkspaceStore(db, dispatchLedgerStore.listOpenDispatchKinds());
     const startExistingWorkspaceWatches = () => {
         for (const workspace of workspaceStore.listWorkspaces()) {
-            void tasksFileWatcher.start(workspace.id, workspace.path);
+            void tasksFileWatcher
+                .start(workspace.id, workspace.path)
+                .catch((error) => logTasksFileWatchStartError(workspace.id, error));
         }
     };
     const restartPolicy = buildRuntimeRestartPolicy({
@@ -48,6 +74,7 @@ export const createRuntimeStoreServices = (options = {}) => {
         messageLogStore,
         tasksFileService,
         workspaceStore,
+        getFlags,
     });
     const workerOutputTracker = options.agentManager
         ? createWorkerOutputTracker(options.agentManager.getOutputBus())
@@ -57,7 +84,70 @@ export const createRuntimeStoreServices = (options = {}) => {
         if (!workspaceStore.hasAgent(workspaceId, agentId))
             return;
         workspaceStore.markAgentStopped(workspaceId, agentId);
-    }, restartPolicy, (workspaceId, agentId) => workspaceStore.getAgent(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);
+    // Mirrors runtime-store.deleteWorker (stop run → drop launch config → drop
+    // dispatches → drop worker row, transactionally). 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);
+        if (activeRun)
+            agentRuntime.stopAgentRun(activeRun.runId);
+        agentRuntime.deleteAgentLaunchConfig(workspaceId, workerId);
+        db.transaction(() => {
+            dispatchLedgerStore.deleteWorkerDispatches(workspaceId, workerId);
+            workspaceStore.deleteWorker(workspaceId, workerId);
+        })();
+    }
+    // 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,
@@ -69,8 +159,13 @@ export const createRuntimeStoreServices = (options = {}) => {
         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,
@@ -85,7 +180,12 @@ export const createRuntimeStoreServices = (options = {}) => {
         tasksFileService,
         teamOps,
         uiAuth,
+        webhookNotifier,
         workerOutputTracker,
+        workflowDispatchAwaiter,
+        workflowRunLogStore,
+        workflowRunStore,
+        workflowScheduleStore,
         workspaceStore,
     };
 };
@@ -143,6 +243,10 @@ export const createRuntimeStoreLifecycle = ({ agentManager, services, }) => {
     };
     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.agentRuntime.close();
             await services.tasksFileWatcher.close();

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

@@ -1,73 +1,4 @@
-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 { SettingsStore } from './settings-store.js';
-import type { CancelTaskInput, DispatchTaskInput, ReportTaskInput, ReportTaskResult, StatusTaskInput } from './team-operations.js';
-import type { TerminalRunSummary } from './terminal-input-profile.js';
-import type { WorkerInput, WorkspaceRecord } from './workspace-store.js';
-interface RuntimeStore {
-    close: () => Promise<void>;
-    createWorkspace: (path: string, name: string) => WorkspaceSummary;
-    deleteWorkspace: (workspaceId: string) => Promise<void>;
-    listWorkspaces: () => WorkspaceSummary[];
-    addWorker: (workspaceId: string, input: WorkerInput) => 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;
-    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[];
-    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;
-}
-interface RuntimeStoreOptions {
-    dataDir?: string;
-    agentManager?: AgentManager;
-}
-interface StartAgentOptions {
-    hivePort: string;
-}
-export type { RuntimeStore };
+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;

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

@@ -1,4 +1,6 @@
-import { createRuntimeStoreLifecycle, createRuntimeStoreServices } from './runtime-store-helpers.js';
+import { createRuntimeStoreLifecycle, createRuntimeStoreServices, logTasksFileWatchStartError, } from './runtime-store-helpers.js';
+import { createRuntimeStoreWorkflowRuntime } from './runtime-store-workflows.js';
+import { persistWorkflowSchedule } from './workflow-schedule-create.js';
 export const createRuntimeStore = (options = {}) => {
     const services = createRuntimeStoreServices(options);
     const lifecycle = createRuntimeStoreLifecycle(options.agentManager ? { agentManager: options.agentManager, services } : { services });
@@ -9,11 +11,22 @@ export const createRuntimeStore = (options = {}) => {
         }
         services.db.transaction(mutation)();
     };
-    return {
-        close: lifecycle.close,
+    let workflowRuntime;
+    const getWorkflowRuntime = () => {
+        if (!workflowRuntime)
+            throw new Error('Workflow runtime not initialized');
+        return workflowRuntime;
+    };
+    const store = {
+        close: async () => {
+            workflowRuntime?.scheduler.close();
+            await lifecycle.close();
+        },
         createWorkspace: (path, name) => {
             const workspace = services.workspaceStore.createWorkspace(path, name);
-            void lifecycle.startWorkspaceWatch(workspace.id);
+            void lifecycle
+                .startWorkspaceWatch(workspace.id)
+                .catch((error) => logTasksFileWatchStartError(workspace.id, error));
             return workspace;
         },
         listWorkspaces: () => services.workspaceStore.listWorkspaces(),
@@ -36,6 +49,34 @@ export const createRuntimeStore = (options = {}) => {
             }
         },
         addWorker: (workspaceId, input) => services.workspaceStore.addWorker(workspaceId, input),
+        addWorkerWithLaunch: (workspaceId, input, launchConfig) => {
+            // Atomic spawn: create the worker AND its launch config together so a
+            // failure can never persist a worker with no way to start it. The DB
+            // transaction rolls back the row; the catch prunes the in-memory worker
+            // that addWorker already pushed into the workspace record.
+            let worker;
+            try {
+                runDataMutation(() => {
+                    worker = store.addWorker(workspaceId, input);
+                    store.configureAgentLaunch(workspaceId, worker.id, launchConfig);
+                });
+            }
+            catch (error) {
+                if (worker) {
+                    try {
+                        store.deleteWorker(workspaceId, worker.id);
+                    }
+                    catch {
+                        // The transaction already removed the DB row; this only prunes the
+                        // stale in-memory entry, which may already be gone.
+                    }
+                }
+                throw error;
+            }
+            if (!worker)
+                throw new Error('addWorkerWithLaunch produced no worker');
+            return worker;
+        },
         renameWorker: (workspaceId, workerId, name) => services.workspaceStore.renameWorker(workspaceId, workerId, name),
         deleteWorker: (workspaceId, workerId) => {
             const activeRun = services.agentRuntime.getActiveRunByAgentId(workspaceId, workerId);
@@ -52,6 +93,7 @@ export const createRuntimeStore = (options = {}) => {
         dispatchTask: services.teamOps.dispatchTask,
         dispatchTaskByWorkerName: services.teamOps.dispatchTaskByWorkerName,
         reportTask: services.teamOps.reportTask,
+        drainReportOutbox: services.teamOps.drainReportOutbox,
         statusTask: services.teamOps.statusTask,
         listDispatches: services.dispatchLedgerStore.listWorkspaceDispatches,
         listWorkers: (workspaceId) => services.workspaceStore.listWorkers(workspaceId),
@@ -83,5 +125,30 @@ export const createRuntimeStore = (options = {}) => {
         stopAgentRun: lifecycle.stopTerminalRun,
         validateAgentToken: (agentId, token) => services.agentRuntime.validateAgentToken(agentId, token),
         validateUiToken: (token) => services.uiAuth.validate(token),
+        getWorkflowDispatchAwaiter: () => services.workflowDispatchAwaiter,
+        runWorkflow: (input) => getWorkflowRuntime().runner.runWorkflow(input),
+        startWorkflow: (input) => getWorkflowRuntime().runner.startWorkflow(input),
+        startWorkflowInline: (input) => getWorkflowRuntime().runner.startWorkflowInline(input),
+        stopWorkflowRun: (runId) => getWorkflowRuntime().runner.stopRun(runId),
+        getWorkflowRun: (runId) => services.workflowRunStore.getRun(runId),
+        listWorkspaceWorkflowRuns: (workspaceId) => services.workflowRunStore.listWorkspaceRuns(workspaceId),
+        listWorkflowRunDispatches: (runId) => services.dispatchLedgerStore.listWorkflowRunDispatches(runId),
+        listWorkflowRunLogs: (runId) => services.workflowRunLogStore.listForRun(runId).map((row) => ({
+            id: row.id,
+            ts: row.ts,
+            message: row.message,
+        })),
+        createWorkflowSchedule: (input) => services.workflowScheduleStore.create(input),
+        scheduleWorkflowInline: (input) => persistWorkflowSchedule({
+            workspacePath: services.workspaceStore.getWorkspaceSnapshot(input.workspaceId).summary.path,
+            scheduleStore: services.workflowScheduleStore,
+            ...input,
+        }),
+        updateWorkflowSchedule: (id, input) => services.workflowScheduleStore.update(id, input),
+        getWorkflowSchedule: (id) => services.workflowScheduleStore.get(id),
+        listWorkspaceWorkflowSchedules: (workspaceId) => services.workflowScheduleStore.listForWorkspace(workspaceId),
+        deleteWorkflowSchedule: (id) => services.workflowScheduleStore.deleteSchedule(id),
     };
+    workflowRuntime = createRuntimeStoreWorkflowRuntime(services, store);
+    return store;
 };