@tt-a1i/hive 1.4.3 → 1.5.0

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

@@ -9,38 +9,61 @@ 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 { AUTOSTAFF_ENABLED_KEY, readAutostaffEnabled } from './team-autostaff.js';
 import { createTeamOperations } from './team-operations.js';
 import { resolveTerminalInputProfile } from './terminal-input-profile.js';
 import { createUiAuth } from './ui-auth.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 { readWorkflowEnabled, WORKFLOW_ENABLED_KEY } from './workflow-feature.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 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 getWorkflowsEnabled = () => readWorkflowEnabled(settings.getAppState(WORKFLOW_ENABLED_KEY)?.value ?? null);
+    const getAutostaffEnabled = () => readAutostaffEnabled(settings.getAppState(AUTOSTAFF_ENABLED_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),
+        getWorkflowsEnabled,
+        getAutostaffEnabled,
     });
     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 +71,8 @@ export const createRuntimeStoreServices = (options = {}) => {
         messageLogStore,
         tasksFileService,
         workspaceStore,
+        getWorkflowsEnabled,
+        getAutostaffEnabled,
     });
     const workerOutputTracker = options.agentManager
         ? createWorkerOutputTracker(options.agentManager.getOutputBus())
@@ -57,7 +82,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), getWorkflowsEnabled, getAutostaffEnabled);
+    // 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 +157,11 @@ export const createRuntimeStoreServices = (options = {}) => {
         markDispatchCancelled: dispatchLedgerStore.markCancelled,
         markDispatchReportedByWorker: dispatchLedgerStore.markReportedByWorker,
         markDispatchSubmitted: dispatchLedgerStore.markSubmitted,
+        workflowDispatchAwaiter,
         workspaceStore,
+        dismissEphemeralWorker: (workspaceId, workerId) => removeWorkerCompletely(workspaceId, workerId),
     });
+    cleanupOrphanEphemeralWorkers();
     startExistingWorkspaceWatches();
     return {
         agentRunStore,
@@ -86,6 +177,10 @@ export const createRuntimeStoreServices = (options = {}) => {
         teamOps,
         uiAuth,
         workerOutputTracker,
+        workflowDispatchAwaiter,
+        workflowRunLogStore,
+        workflowRunStore,
+        workflowScheduleStore,
         workspaceStore,
     };
 };
@@ -143,6 +238,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,100 @@
+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);
+            }
+        },
+        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,71 +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>;
-    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);
@@ -83,5 +124,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;
 };

package/dist/src/server/session-capture-claude.d.ts

@@ -1,4 +1,27 @@
 export declare const getClaudeProjectsRoot: (pattern?: string) => string;
+/**
+ * Match the directory-name encoding Claude Code itself uses for its project
+ * metadata under `~/.claude/projects/`. Empirically (probed via `claude
+ * --print "x"` in directories named with each character) Claude Code
+ * replaces *every* character outside `[A-Za-z0-9-]` with a single `-`,
+ * one-for-one, preserving literal hyphens.
+ *
+ * The previous regex `[\\/:\s]` only matched `\`, `/`, `:`, and whitespace —
+ * leaving `_`, `.`, parens, brackets, `@`, `#`, `&`, `+`, and any non-ASCII
+ * character (including CJK usernames) intact, while Claude Code's own
+ * encoder replaced them. The mismatch meant Hive looked for sessions under
+ * a different directory than the one Claude Code wrote to, so session
+ * resume silently failed for any workspace path containing those chars.
+ * Windows + CJK Windows usernames (`C:\Users\张三\project`) and
+ * underscored Windows project paths (`C:\my_project`) are the most common
+ * triggers, but the bug is cross-platform.
+ *
+ * Backward compatibility: workspaces whose path contains ONLY chars that
+ * the old regex already matched (`/\:` + whitespace) get the same encoded
+ * dirname as before — no behavior change. Workspaces with any other
+ * special chars previously had broken session resume; the fix moves them
+ * to the correct (working) directory.
+ */
 export declare const encodeClaudeProjectPath: (cwd: string) => string;
 interface ClaudeSessionCaptureDiscriminator {
     contentIncludes?: string | readonly string[];

package/dist/src/server/session-capture-claude.js

@@ -18,7 +18,30 @@ export const getClaudeProjectsRoot = (pattern) => {
     }
     return root;
 };
-export const encodeClaudeProjectPath = (cwd) => cwd.replace(/[\\/:\s]/g, '-');
+/**
+ * Match the directory-name encoding Claude Code itself uses for its project
+ * metadata under `~/.claude/projects/`. Empirically (probed via `claude
+ * --print "x"` in directories named with each character) Claude Code
+ * replaces *every* character outside `[A-Za-z0-9-]` with a single `-`,
+ * one-for-one, preserving literal hyphens.
+ *
+ * The previous regex `[\\/:\s]` only matched `\`, `/`, `:`, and whitespace —
+ * leaving `_`, `.`, parens, brackets, `@`, `#`, `&`, `+`, and any non-ASCII
+ * character (including CJK usernames) intact, while Claude Code's own
+ * encoder replaced them. The mismatch meant Hive looked for sessions under
+ * a different directory than the one Claude Code wrote to, so session
+ * resume silently failed for any workspace path containing those chars.
+ * Windows + CJK Windows usernames (`C:\Users\张三\project`) and
+ * underscored Windows project paths (`C:\my_project`) are the most common
+ * triggers, but the bug is cross-platform.
+ *
+ * Backward compatibility: workspaces whose path contains ONLY chars that
+ * the old regex already matched (`/\:` + whitespace) get the same encoded
+ * dirname as before — no behavior change. Workspaces with any other
+ * special chars previously had broken session resume; the fix moves them
+ * to the correct (working) directory.
+ */
+export const encodeClaudeProjectPath = (cwd) => cwd.replace(/[^A-Za-z0-9-]/g, '-');
 const listSessionIds = (cwd, projectsRoot = getDefaultProjectsRoot()) => {
     const projectDir = join(projectsRoot, encodeClaudeProjectPath(cwd));
     try {

package/dist/src/server/session-capture-codex.d.ts

@@ -1,6 +1,6 @@
-export declare const getCodexHome: (pattern?: string) => string;
+export declare const getCodexHome: (pattern?: string, platform?: NodeJS.Platform) => string;
 export declare const readCodexSessionFirstLine: (filePath: string, maxBytes?: number) => string | null;
-export declare const hasCodexSession: (cwd: string, sessionId: string, pattern?: string) => boolean;
-export declare const snapshotCodexSessionIds: (cwd: string, codexHome?: string) => Set<string>;
+export declare const hasCodexSession: (cwd: string, sessionId: string, pattern?: string, platform?: NodeJS.Platform, codexHome?: string) => boolean;
+export declare const snapshotCodexSessionIds: (cwd: string, codexHome?: string, platform?: NodeJS.Platform) => Set<string>;
 export declare const captureCodexSessionId: (cwd: string, knownSessionIds: Set<string>, onCapture: (sessionId: string) => void, timeoutMs?: number, intervalMs?: number, codexHome?: string) => Promise<void>;
 export declare const codexSessionStoreExists: (codexHome?: string) => boolean;

package/dist/src/server/session-capture-codex.js

@@ -2,19 +2,21 @@ import { closeSync, existsSync, openSync, readdirSync, readSync } from 'node:fs'
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { captureSessionIdWithCoordinator } from './claude-session-coordinator.js';
+import { arePathsEqual, indexOfPathMarker } from './platform-path.js';
 const CODEX_SESSION_FILE = /^rollout-.*\.jsonl$/i;
+const CODEX_SESSIONS_MARKER = '/sessions/';
 const CODEX_HEADER_READ_CHUNK_BYTES = 4096;
 const CODEX_HEADER_MAX_BYTES = 64 * 1024;
 const getDefaultCodexHome = () => process.env.CODEX_HOME ?? join(homedir(), '.codex');
 const expandHome = (path) => path === '~' || path.startsWith('~/') ? join(homedir(), path.slice(2)) : path;
-export const getCodexHome = (pattern) => {
+export const getCodexHome = (pattern, platform = process.platform) => {
     if (!pattern)
         return getDefaultCodexHome();
-    const markerIndex = pattern.indexOf('/sessions/');
+    const markerIndex = indexOfPathMarker(pattern, CODEX_SESSIONS_MARKER, platform);
     if (markerIndex === -1)
         return getDefaultCodexHome();
     const rawRoot = pattern.slice(0, markerIndex);
-    if (rawRoot === '~/.codex' || rawRoot === '~/.codex/')
+    if (arePathsEqual(rawRoot, '~/.codex', platform) || arePathsEqual(rawRoot, '~/.codex/', platform))
         return getDefaultCodexHome();
     const root = expandHome(rawRoot);
     return root || getDefaultCodexHome();
@@ -78,13 +80,13 @@ const parseCodexSession = (filePath) => {
     const cwd = 'cwd' in payload && typeof payload.cwd === 'string' ? payload.cwd : null;
     return id && cwd ? { cwd, id } : null;
 };
-const listSessionIds = (cwd, codexHome = getDefaultCodexHome()) => {
+const listSessionIds = (cwd, codexHome = getDefaultCodexHome(), platform = process.platform) => {
     const sessionsRoot = join(codexHome, 'sessions');
     return walkSessionFiles(sessionsRoot)
         .flatMap((filePath) => {
         try {
             const session = parseCodexSession(filePath);
-            return session?.cwd === cwd ? [session.id] : [];
+            return session && arePathsEqual(session.cwd, cwd, platform) ? [session.id] : [];
         }
         catch {
             return [];
@@ -92,8 +94,8 @@ const listSessionIds = (cwd, codexHome = getDefaultCodexHome()) => {
     })
         .sort((left, right) => left.localeCompare(right));
 };
-export const hasCodexSession = (cwd, sessionId, pattern) => listSessionIds(cwd, getCodexHome(pattern)).includes(sessionId);
-export const snapshotCodexSessionIds = (cwd, codexHome = getDefaultCodexHome()) => new Set(listSessionIds(cwd, codexHome));
+export const hasCodexSession = (cwd, sessionId, pattern, platform = process.platform, codexHome = getCodexHome(pattern, platform)) => listSessionIds(cwd, codexHome, platform).includes(sessionId);
+export const snapshotCodexSessionIds = (cwd, codexHome = getDefaultCodexHome(), platform = process.platform) => new Set(listSessionIds(cwd, codexHome, platform));
 export const captureCodexSessionId = async (cwd, knownSessionIds, onCapture, timeoutMs = 5000, intervalMs = 100, codexHome = getDefaultCodexHome()) => {
     await captureSessionIdWithCoordinator({
         intervalMs,

package/dist/src/server/session-capture-gemini.d.ts

@@ -1,4 +1,4 @@
-export declare const getGeminiHome: (pattern?: string) => string;
+export declare const getGeminiHome: (pattern?: string, platform?: NodeJS.Platform) => string;
 export declare const hasGeminiSession: (cwd: string, sessionId: string, pattern?: string) => boolean;
 export declare const snapshotGeminiSessionIds: (cwd: string, geminiHome?: string) => Set<string>;
 export declare const captureGeminiSessionId: (cwd: string, knownSessionIds: Set<string>, onCapture: (sessionId: string) => void, timeoutMs?: number, intervalMs?: number, geminiHome?: string) => Promise<void>;

package/dist/src/server/session-capture-gemini.js

@@ -2,13 +2,15 @@ import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { captureSessionIdWithCoordinator } from './claude-session-coordinator.js';
+import { arePathsEqual, indexOfPathMarker } from './platform-path.js';
 const GEMINI_SESSION_FILE = /^session-.*\.json$/i;
+const GEMINI_TMP_MARKER = '/tmp/';
 const getDefaultGeminiHome = () => process.env.HIVE_GEMINI_HOME ?? join(homedir(), '.gemini');
 const expandHome = (path) => path === '~' || path.startsWith('~/') ? join(homedir(), path.slice(2)) : path;
-export const getGeminiHome = (pattern) => {
+export const getGeminiHome = (pattern, platform = process.platform) => {
     if (!pattern)
         return getDefaultGeminiHome();
-    const markerIndex = pattern.indexOf('/tmp/');
+    const markerIndex = indexOfPathMarker(pattern, GEMINI_TMP_MARKER, platform);
     if (markerIndex === -1)
         return getDefaultGeminiHome();
     const rawRoot = pattern.slice(0, markerIndex);
@@ -38,7 +40,8 @@ const listSessionIds = (cwd, geminiHome = getDefaultGeminiHome()) => {
             .filter((entry) => entry.isDirectory())
             .flatMap((entry) => {
             const projectDir = join(tmpRoot, entry.name);
-            if (readProjectRoot(projectDir) !== cwd)
+            const projectRoot = readProjectRoot(projectDir);
+            if (projectRoot === null || !arePathsEqual(projectRoot, cwd))
                 return [];
             const chatsDir = join(projectDir, 'chats');
             try {

package/dist/src/server/session-capture-opencode.d.ts

@@ -1,3 +1,21 @@
+/**
+ * Resolve the path OpenCode upstream writes `opencode.db` to. Branches
+ * by platform because XDG_DATA_HOME is not a Windows convention — the
+ * previous unconditional ~/.local/share/opencode/opencode.db default
+ * pointed at a path that never exists on Windows, silently breaking
+ * Layer A native session resume for OpenCode workers there.
+ *
+ * Resolution order:
+ *   1. HIVE_OPENCODE_DB_PATH override (any platform, for tests/users).
+ *   2. Windows: %LOCALAPPDATA%\opencode\opencode.db (with a homedir
+ *      fallback when LOCALAPPDATA is missing — some shells strip env).
+ *   3. POSIX: $XDG_DATA_HOME/opencode/opencode.db, falling back to
+ *      ~/.local/share/opencode/opencode.db.
+ *
+ * Exported so the path-resolution rules can be unit-tested without
+ * needing to mock the underlying SQLite open.
+ */
+export declare const getDefaultOpenCodeDbPath: (platform?: NodeJS.Platform) => string;
 export declare const getOpenCodeDbPath: (pattern?: string) => string;
 export declare const hasOpenCodeSession: (cwd: string, sessionId: string, pattern?: string) => boolean;
 export declare const snapshotOpenCodeSessionIds: (cwd: string, dbPath?: string) => Set<string>;