@tt-a1i/hive 1.4.3 → 1.5.0

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

@@ -1,6 +1,24 @@
-import { BadRequestError } from './http-errors.js';
+import { randomUUID } from 'node:crypto';
+import { resolveCommandPresetLaunchConfig } from './agent-launch-resolver.js';
+import { validateCronNextRunAt } from './cron-util.js';
+import { BadRequestError, ForbiddenError } from './http-errors.js';
 import { readJsonBody, route, sendJson } from './route-helpers.js';
 import { authenticateCliAgent, requireCommandForRole } from './team-authz.js';
+import { readWorkflowEnabled, WORKFLOW_ENABLED_KEY } from './workflow-feature.js';
+const WORKER_ROLES = new Set(['coder', 'reviewer', 'tester', 'custom']);
+const toWorkerRole = (value) => value && WORKER_ROLES.has(value) ? value : 'coder';
+// Experimental gate: `team workflow run` / `team workflow schedule` only work
+// when the user has enabled workflows in Settings. Off by default. The PTY
+// runner itself isn't gated (internal API + the scheduler gate handle that) —
+// this is the agent-facing entry point, so the orchestrator gets a clear,
+// actionable error instead of a silent no-op.
+const requireWorkflowsEnabled = (store) => {
+    if (!readWorkflowEnabled(store.settings.getAppState(WORKFLOW_ENABLED_KEY)?.value ?? null)) {
+        throw new ForbiddenError('Workflows are an experimental Hive feature and are currently disabled. ' +
+            'Enable them in Hive Settings (the gear menu, top-right) to use `team workflow`. ' +
+            'Until then, dispatch work with `team send`.');
+    }
+};
 const requireNonEmptyString = (value, field) => {
     if (typeof value !== 'string' || value.trim().length === 0) {
         throw new BadRequestError(`Missing ${field}`);
@@ -27,7 +45,208 @@ export const teamRoutes = [
             fromAgentId,
             hivePort: String(request.socket.localPort ?? ''),
         });
-        sendJson(response, 202, { dispatch_id: dispatch.id, ok: true });
+        /* `restarted_worker` makes the silent auto-wake transparent — when
+           the worker had no active run at dispatch time, ensureWorkerRun
+           spawned a fresh PTY for it. The orchestrator's CLI prints a
+           stderr notice on this flag so the agent can explain the wake-up
+           to the user instead of being out of sync with worker state. */
+        sendJson(response, 202, {
+            dispatch_id: dispatch.id,
+            ok: true,
+            restarted_worker: dispatch.restartedWorker,
+        });
+    }),
+    route('POST', '/api/team/spawn', async ({ request, response, store }) => {
+        const body = await readJsonBody(request);
+        const projectId = requireNonEmptyString(body.project_id, 'project_id');
+        const fromAgentId = requireNonEmptyString(body.from_agent_id, 'from_agent_id');
+        const agent = authenticateCliAgent({
+            fromAgentId,
+            getAgent: store.getAgent,
+            token: body.token,
+            validateToken: store.validateAgentToken,
+            workspaceId: projectId,
+        });
+        requireCommandForRole(agent, 'spawn');
+        const role = toWorkerRole(body.role);
+        const name = typeof body.name === 'string' && body.name.trim().length > 0
+            ? body.name.trim()
+            : `${role}-${randomUUID()}`;
+        const launchConfig = (body.cli ? resolveCommandPresetLaunchConfig(store.settings, body.cli) : undefined) ??
+            { command: body.cli ?? 'claude', args: [] };
+        // M11: default is persistent (acts like a normal member); --ephemeral
+        // opts into auto-dismiss-after-first-report (mirrors workflow workers,
+        // but orchestrator-spawned). Existing M1-D cascade-on-orchestrator-exit
+        // still applies to whatever ephemeral workers remain.
+        const ephemeral = body.ephemeral === true;
+        const workerInput = ephemeral
+            ? { name, role, ephemeral: true, spawnedBy: 'orchestrator' }
+            : { name, role };
+        const worker = store.addWorkerWithLaunch(projectId, workerInput, launchConfig);
+        sendJson(response, 201, {
+            name: worker.name,
+            ok: true,
+            worker_id: worker.id,
+            ephemeral,
+        });
+    }),
+    route('POST', '/api/team/workflow/run', async ({ request, response, store }) => {
+        const body = await readJsonBody(request);
+        const projectId = requireNonEmptyString(body.project_id, 'project_id');
+        const fromAgentId = requireNonEmptyString(body.from_agent_id, 'from_agent_id');
+        const source = requireNonEmptyString(body.source, 'source');
+        const agent = authenticateCliAgent({
+            fromAgentId,
+            getAgent: store.getAgent,
+            token: body.token,
+            validateToken: store.validateAgentToken,
+            workspaceId: projectId,
+        });
+        requireCommandForRole(agent, 'workflow');
+        // Feature gate AFTER auth so an unauthenticated caller gets 401/400, not a
+        // 403 that leaks whether the experiment is on.
+        requireWorkflowsEnabled(store);
+        const hivePort = String(request.socket.localPort ?? '');
+        const input = {
+            workspaceId: projectId,
+            source,
+            hivePort,
+            triggeredByAgentId: fromAgentId,
+            ...(body.args !== undefined ? { args: body.args } : {}),
+            ...(typeof body.name === 'string' && body.name.trim()
+                ? { scriptPath: `<inline:${body.name.trim()}>` }
+                : {}),
+        };
+        const run = await store.startWorkflowInline(input);
+        sendJson(response, 202, { ok: true, run_id: run.id, name: run.name, status: run.status });
+    }),
+    /* Agent-initiated scheduling. Workflows are authored by the orchestrator,
+       not picked from a human script library — so registering a recurring run
+       is also an agent action: the orchestrator passes the workflow source +
+       a cron, and the runtime persists the source (so cron can fire it with no
+       orchestrator in the loop) and registers the schedule. The UI only
+       lists / pauses / deletes schedules; it cannot create them. */
+    route('POST', '/api/team/workflow/schedule', async ({ request, response, store }) => {
+        const body = await readJsonBody(request);
+        const projectId = requireNonEmptyString(body.project_id, 'project_id');
+        const fromAgentId = requireNonEmptyString(body.from_agent_id, 'from_agent_id');
+        const source = requireNonEmptyString(body.source, 'source');
+        const name = requireNonEmptyString(body.name, 'name');
+        const cron = requireNonEmptyString(body.cron, 'cron');
+        const agent = authenticateCliAgent({
+            fromAgentId,
+            getAgent: store.getAgent,
+            token: body.token,
+            validateToken: store.validateAgentToken,
+            workspaceId: projectId,
+        });
+        requireCommandForRole(agent, 'workflow');
+        // Feature gate AFTER auth (see /run above).
+        requireWorkflowsEnabled(store);
+        const nextRunAt = validateCronNextRunAt(cron);
+        const schedule = await store.scheduleWorkflowInline({
+            workspaceId: projectId,
+            source,
+            name,
+            cron,
+            nextRunAt,
+            ...(body.args !== undefined ? { args: body.args } : {}),
+        });
+        sendJson(response, 201, {
+            ok: true,
+            schedule_id: schedule.id,
+            script_path: schedule.scriptPath,
+            cron: schedule.cron,
+            next_run_at: schedule.nextRunAt,
+        });
+    }),
+    route('POST', '/api/team/workflow/stop', async ({ request, response, store }) => {
+        const body = await readJsonBody(request);
+        const projectId = requireNonEmptyString(body.project_id, 'project_id');
+        const fromAgentId = requireNonEmptyString(body.from_agent_id, 'from_agent_id');
+        const runId = requireNonEmptyString(body.run_id, 'run_id');
+        const agent = authenticateCliAgent({
+            fromAgentId,
+            getAgent: store.getAgent,
+            token: body.token,
+            validateToken: store.validateAgentToken,
+            workspaceId: projectId,
+        });
+        requireCommandForRole(agent, 'workflow');
+        const stopped = store.stopWorkflowRun(runId);
+        sendJson(response, stopped ? 202 : 409, { ok: stopped, run_id: runId });
+    }),
+    /* TIER 1 #6 — per-agent transcript dump. The completion reminder injected
+       into the orchestrator's stdin promised this command but it never
+       existed, so any orchestrator that followed the suggestion got a
+       usage error. Returns the run record + the full per-dispatch detail
+       (step / phase / label / prompt / status / report text) so the
+       orchestrator can read past the 200-char per-step summary cap in the
+       reminder. */
+    route('POST', '/api/team/workflow/show', async ({ request, response, store }) => {
+        const body = await readJsonBody(request);
+        const projectId = requireNonEmptyString(body.project_id, 'project_id');
+        const fromAgentId = requireNonEmptyString(body.from_agent_id, 'from_agent_id');
+        const runId = requireNonEmptyString(body.run_id, 'run_id');
+        const agent = authenticateCliAgent({
+            fromAgentId,
+            getAgent: store.getAgent,
+            token: body.token,
+            validateToken: store.validateAgentToken,
+            workspaceId: projectId,
+        });
+        requireCommandForRole(agent, 'workflow');
+        const run = store.getWorkflowRun(runId);
+        if (!run || run.workspaceId !== projectId) {
+            sendJson(response, 404, { error: `Workflow run not found: ${runId}` });
+            return;
+        }
+        const dispatches = store.listWorkflowRunDispatches(runId).map((d) => ({
+            step_index: d.stepIndex,
+            phase: d.phase,
+            label: d.label,
+            to_agent_id: d.toAgentId,
+            status: d.status,
+            text: d.text,
+            report_text: d.reportText,
+            submitted_at: d.submittedAt,
+            reported_at: d.reportedAt,
+        }));
+        sendJson(response, 200, {
+            ok: true,
+            run: {
+                id: run.id,
+                name: run.name,
+                status: run.status,
+                phase: run.phase,
+                started_at: run.startedAt,
+                finished_at: run.finishedAt,
+                error: run.error,
+                result: run.result,
+            },
+            dispatches,
+        });
+    }),
+    route('POST', '/api/team/dismiss', async ({ request, response, store }) => {
+        const body = await readJsonBody(request);
+        const projectId = requireNonEmptyString(body.project_id, 'project_id');
+        const fromAgentId = requireNonEmptyString(body.from_agent_id, 'from_agent_id');
+        const name = requireNonEmptyString(body.name, 'name');
+        const agent = authenticateCliAgent({
+            fromAgentId,
+            getAgent: store.getAgent,
+            token: body.token,
+            validateToken: store.validateAgentToken,
+            workspaceId: projectId,
+        });
+        requireCommandForRole(agent, 'dismiss');
+        const worker = store.listWorkers(projectId).find((item) => item.name === name);
+        if (!worker) {
+            sendJson(response, 404, { error: `No such worker: ${name}` });
+            return;
+        }
+        store.deleteWorker(projectId, worker.id);
+        sendJson(response, 200, { ok: true });
     }),
     route('POST', '/api/team/cancel', async ({ request, response, store }) => {
         const body = await readJsonBody(request);

package/dist/src/server/routes-workflow-schedules.d.ts

@@ -0,0 +1,2 @@
+import type { RouteDefinition } from './route-types.js';
+export declare const workflowScheduleRoutes: RouteDefinition[];

package/dist/src/server/routes-workflow-schedules.js

@@ -0,0 +1,58 @@
+import { validateCronNextRunAt } from './cron-util.js';
+import { getRequiredParam, readJsonBody, route, sendJson } from './route-helpers.js';
+import { requireUiTokenFromRequest } from './ui-auth-helpers.js';
+import { serializeWorkflowSchedule } from './workflow-http-serializers.js';
+// Schedules are CREATED by the orchestrator agent (`team workflow schedule`),
+// which persists the workflow source so cron can fire it with no orchestrator
+// in the loop. The UI only LISTS / PAUSES / RESUMES / DELETES them — there is
+// no human create route here.
+export const workflowScheduleRoutes = [
+    route('GET', '/api/workspaces/:workspaceId/workflow-schedules', ({ params, request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken);
+        const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Missing workspaceId');
+        if (!workspaceId)
+            return;
+        sendJson(response, 200, {
+            schedules: store.listWorkspaceWorkflowSchedules(workspaceId).map(serializeWorkflowSchedule),
+        });
+    }),
+    route('PATCH', '/api/workflow-schedules/:scheduleId', async ({ params, request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken);
+        const scheduleId = getRequiredParam(response, params, 'scheduleId', 'Missing scheduleId');
+        if (!scheduleId)
+            return;
+        const existing = store.getWorkflowSchedule(scheduleId);
+        if (!existing) {
+            sendJson(response, 404, { error: `Schedule not found: ${scheduleId}` });
+            return;
+        }
+        const body = await readJsonBody(request);
+        const update = {};
+        if (typeof body.cron === 'string') {
+            update.cron = body.cron;
+            update.nextRunAt = validateCronNextRunAt(body.cron);
+        }
+        if (body.args !== undefined)
+            update.args = body.args;
+        if (typeof body.enabled === 'boolean')
+            update.enabled = body.enabled;
+        store.updateWorkflowSchedule(scheduleId, update);
+        const refreshed = store.getWorkflowSchedule(scheduleId);
+        sendJson(response, 200, {
+            schedule: refreshed ? serializeWorkflowSchedule(refreshed) : null,
+        });
+    }),
+    route('DELETE', '/api/workflow-schedules/:scheduleId', ({ params, request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken);
+        const scheduleId = getRequiredParam(response, params, 'scheduleId', 'Missing scheduleId');
+        if (!scheduleId)
+            return;
+        const existing = store.getWorkflowSchedule(scheduleId);
+        if (!existing) {
+            sendJson(response, 404, { error: `Schedule not found: ${scheduleId}` });
+            return;
+        }
+        store.deleteWorkflowSchedule(scheduleId);
+        sendJson(response, 200, { ok: true });
+    }),
+];

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

@@ -0,0 +1,2 @@
+import type { RouteDefinition } from './route-types.js';
+export declare const workflowRoutes: RouteDefinition[];

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

@@ -0,0 +1,83 @@
+import { getRequiredParam, route, sendJson } from './route-helpers.js';
+import { requireUiTokenFromRequest } from './ui-auth-helpers.js';
+import { serializeWorkflowDispatch, serializeWorkflowRun } from './workflow-http-serializers.js';
+// Workflows are authored and fired by the orchestrator agent (`team workflow
+// run` / `team workflow schedule`), never from a human script library — so the
+// UI surface here is purely OBSERVABILITY + run control (list / get / stop /
+// per-agent dispatch timeline / narrator logs). There is no list-scripts,
+// start-by-path, template-install, or source-editor route.
+export const workflowRoutes = [
+    route('GET', '/api/workspaces/:workspaceId/workflows/runs', ({ params, request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken);
+        const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Missing workspaceId');
+        if (!workspaceId)
+            return;
+        sendJson(response, 200, {
+            runs: store.listWorkspaceWorkflowRuns(workspaceId).map(serializeWorkflowRun),
+        });
+    }),
+    route('GET', '/api/workflows/runs/:runId', ({ params, request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken);
+        const runId = getRequiredParam(response, params, 'runId', 'Missing runId');
+        if (!runId)
+            return;
+        const run = store.getWorkflowRun(runId);
+        if (!run) {
+            sendJson(response, 404, { error: `Workflow run not found: ${runId}` });
+            return;
+        }
+        sendJson(response, 200, { run: serializeWorkflowRun(run) });
+    }),
+    route('POST', '/api/workflows/runs/:runId/stop', ({ params, request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken);
+        const runId = getRequiredParam(response, params, 'runId', 'Missing runId');
+        if (!runId)
+            return;
+        const run = store.getWorkflowRun(runId);
+        if (!run) {
+            sendJson(response, 404, { error: `Workflow run not found: ${runId}` });
+            return;
+        }
+        const stopped = store.stopWorkflowRun(runId);
+        sendJson(response, stopped ? 202 : 409, {
+            ok: stopped,
+            ...(stopped ? {} : { error: `Run is not running (status=${run.status})` }),
+        });
+    }),
+    route('GET', '/api/workflows/runs/:runId/dispatches', ({ params, request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken);
+        const runId = getRequiredParam(response, params, 'runId', 'Missing runId');
+        if (!runId)
+            return;
+        const run = store.getWorkflowRun(runId);
+        if (!run) {
+            sendJson(response, 404, { error: `Workflow run not found: ${runId}` });
+            return;
+        }
+        /* TIER 2 #6 — enrich `submitted` dispatches with the worker's
+           lastPtyLine so the Drawer can show what each ephemeral worker is
+           currently doing (without forcing the user to jump to the
+           worker's terminal pane). For reported/cancelled rows the report
+           text is already authoritative, no need to also surface PTY noise. */
+        const dispatches = store.listWorkflowRunDispatches(runId).map((d) => {
+            if (d.status !== 'submitted')
+                return d;
+            const lastPtyLine = store.getLastPtyLineForAgent(run.workspaceId, d.toAgentId);
+            return lastPtyLine === null ? d : { ...d, lastPtyLine };
+        });
+        sendJson(response, 200, { dispatches: dispatches.map(serializeWorkflowDispatch) });
+    }),
+    /* TIER 2 #3 — narrator lane. Drawer polls this alongside dispatches.
+       Same auth path; same 404 semantics. */
+    route('GET', '/api/workflows/runs/:runId/logs', ({ params, request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken);
+        const runId = getRequiredParam(response, params, 'runId', 'Missing runId');
+        if (!runId)
+            return;
+        if (!store.getWorkflowRun(runId)) {
+            sendJson(response, 404, { error: `Workflow run not found: ${runId}` });
+            return;
+        }
+        sendJson(response, 200, { logs: store.listWorkflowRunLogs(runId) });
+    }),
+];

package/dist/src/server/routes.js

@@ -9,6 +9,8 @@ import { taskRoutes } from './routes-tasks.js';
 import { teamRoutes } from './routes-team.js';
 import { uiRoutes } from './routes-ui.js';
 import { versionRoutes } from './routes-version.js';
+import { workflowScheduleRoutes } from './routes-workflow-schedules.js';
+import { workflowRoutes } from './routes-workflows.js';
 import { workspaceRoutes } from './routes-workspaces.js';
 const routes = [
     ...workspaceRoutes,
@@ -22,6 +24,8 @@ const routes = [
     ...teamRoutes,
     ...fsRoutes,
     ...marketplaceRoutes,
+    ...workflowRoutes,
+    ...workflowScheduleRoutes,
 ];
 export const matchRoute = (method, pathname) => {
     for (const routeDefinition of routes) {

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

@@ -2,7 +2,7 @@ import type { AgentRunStorePort } from './agent-runtime-ports.js';
 import type { MessageLogHandle, MessageLogRecord, RecoveryMessage } from './message-log-store.js';
 import type { TasksFileService } from './tasks-file.js';
 import type { WorkspaceStore } from './workspace-store.js';
-export declare const buildRuntimeRestartPolicy: ({ agentRunStore, messageLogStore, tasksFileService, workspaceStore, }: {
+export declare const buildRuntimeRestartPolicy: ({ agentRunStore, messageLogStore, tasksFileService, workspaceStore, getWorkflowsEnabled, getAutostaffEnabled, }: {
     agentRunStore: Pick<AgentRunStorePort, "listAgentRuns">;
     messageLogStore: {
         deleteMessage: (handle: MessageLogHandle) => void;
@@ -11,4 +11,6 @@ export declare const buildRuntimeRestartPolicy: ({ agentRunStore, messageLogStor
     };
     tasksFileService: Pick<TasksFileService, "readTasks">;
     workspaceStore: Pick<WorkspaceStore, "getWorkspaceSnapshot">;
+    getWorkflowsEnabled?: () => boolean;
+    getAutostaffEnabled?: () => boolean;
 }) => import("./restart-policy.js").RestartPolicy;

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

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

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

@@ -0,0 +1,122 @@
+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;
+    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

@@ -12,6 +12,10 @@ import { createTasksFileWatcher } from './tasks-file-watcher.js';
 import { createTeamOperations } from './team-operations.js';
 import { createUiAuth } from './ui-auth.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 {
@@ -28,6 +32,10 @@ export interface RuntimeStoreServices {
     teamOps: ReturnType<typeof createTeamOperations>;
     uiAuth: ReturnType<typeof createUiAuth>;
     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 +46,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>;