@fkqfkq123/opencode-autopilot 0.1.0

package/dist/packages/runtime/src/presentation/watch-renderer.d.ts

@@ -0,0 +1,12 @@
+import type { HumanActionRecord } from "../../../core/src/human-actions/human-action-record";
+import type { WorkflowRuntimeState } from "../../../core/src/state/workflow-runtime-state";
+import type { WorkflowState } from "../../../core/src/state/workflow-state";
+import type { WorkflowEventRecord } from "../events/workflow-event-store";
+export declare function renderWatchFrame(args: {
+    workflow: WorkflowState;
+    runtime: WorkflowRuntimeState | null;
+    humanAction: HumanActionRecord | null;
+    recentEvents: WorkflowEventRecord[];
+    attached: boolean;
+    modeLabel?: string;
+}): string;

package/dist/packages/runtime/src/presentation/watch-renderer.js

@@ -0,0 +1,17 @@
+import { renderHumanActionBlock } from "./human-action-renderer";
+export function renderWatchFrame(args) {
+    const { workflow, runtime, humanAction, recentEvents, attached, modeLabel = "Autopilot" } = args;
+    const lines = [
+        `Mode: ${modeLabel}`,
+        `Attached: ${attached ? "yes" : "no"}`,
+        renderHumanActionBlock({ workflow, runtime, humanAction }),
+    ];
+    if (recentEvents.length > 0) {
+        lines.push("");
+        lines.push("Recent events:");
+        for (const event of recentEvents.slice(-5)) {
+            lines.push(`- ${event.at} ${event.type}`);
+        }
+    }
+    return lines.join("\n");
+}

package/dist/packages/runtime/src/recovery/basic-recovery-classifier.d.ts

@@ -0,0 +1,4 @@
+import type { RecoveryClassifier, RecoveryDisposition } from "./recovery-classifier";
+export declare class BasicRecoveryClassifier implements RecoveryClassifier {
+    classify(error: unknown): RecoveryDisposition;
+}

package/dist/packages/runtime/src/recovery/basic-recovery-classifier.js

@@ -0,0 +1,12 @@
+export class BasicRecoveryClassifier {
+    classify(error) {
+        const message = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
+        if (message.includes("timeout") || message.includes("temporary")) {
+            return "retryable";
+        }
+        if (message.includes("missing") || message.includes("stale")) {
+            return "recoverable";
+        }
+        return "terminal";
+    }
+}

package/dist/packages/runtime/src/recovery/recovery-classifier.d.ts

@@ -0,0 +1,4 @@
+export type RecoveryDisposition = "retryable" | "recoverable" | "terminal";
+export interface RecoveryClassifier {
+    classify(error: unknown): RecoveryDisposition;
+}

package/dist/packages/runtime/src/recovery/recovery-classifier.js

@@ -0,0 +1 @@
+export {};

package/dist/packages/runtime/src/scheduling/immediate-tick-scheduler.d.ts

@@ -0,0 +1,9 @@
+import type { TickScheduler } from "./tick-scheduler";
+export type TickHandler = (workflowId: string) => Promise<void>;
+export declare class ImmediateTickScheduler implements TickScheduler {
+    private readonly active;
+    private readonly queued;
+    private handler;
+    setHandler(handler: TickHandler): void;
+    requestTick(workflowId: string, _reason: string): Promise<void>;
+}

package/dist/packages/runtime/src/scheduling/immediate-tick-scheduler.js

@@ -0,0 +1,28 @@
+export class ImmediateTickScheduler {
+    active = new Set();
+    queued = new Set();
+    handler = null;
+    setHandler(handler) {
+        this.handler = handler;
+    }
+    async requestTick(workflowId, _reason) {
+        if (!this.handler) {
+            throw new Error("Tick handler has not been registered");
+        }
+        if (this.active.has(workflowId)) {
+            this.queued.add(workflowId);
+            return;
+        }
+        this.active.add(workflowId);
+        try {
+            await this.handler(workflowId);
+            while (this.queued.has(workflowId)) {
+                this.queued.delete(workflowId);
+                await this.handler(workflowId);
+            }
+        }
+        finally {
+            this.active.delete(workflowId);
+        }
+    }
+}

package/dist/packages/runtime/src/scheduling/tick-scheduler.d.ts

@@ -0,0 +1,3 @@
+export interface TickScheduler {
+    requestTick(workflowId: string, reason: string): Promise<void>;
+}

package/dist/packages/runtime/src/scheduling/tick-scheduler.js

@@ -0,0 +1 @@
+export {};

package/dist/packages/runtime/src/sessions/file-system-session-coordinator.d.ts

@@ -0,0 +1,19 @@
+import type { Phase } from "../../../core/src/state/phase";
+import type { SessionEvent } from "../../../adapters/opencode/src/opencode-session-client";
+import type { RelevantSessionState } from "../../../core/src/transitions/phase-transition";
+import type { OpencodeSessionClient } from "../../../adapters/opencode/src/opencode-session-client";
+import type { WorkflowWorkspace } from "../workspace/workflow-workspace";
+import type { SessionCoordinator, SessionDescriptor } from "./session-coordinator";
+export declare class FileSystemSessionCoordinator implements SessionCoordinator {
+    private readonly workspace;
+    private readonly sessionClient;
+    constructor(workspace: WorkflowWorkspace, sessionClient: OpencodeSessionClient);
+    getRelevantSession(workflowId: string): Promise<RelevantSessionState>;
+    ensureSession(workflowId: string, phase: Phase, preferredSessionId?: string | null): Promise<string>;
+    inject(workflowId: string, sessionId: string, prompt: string): Promise<void>;
+    archiveIrrelevantSessions(workflowId: string, phase: Phase): Promise<void>;
+    getStoredSession(workflowId: string, sessionId: string): Promise<SessionDescriptor | null>;
+    streamEvents(session: SessionDescriptor): AsyncIterable<SessionEvent>;
+    private loadSessions;
+    private saveSessions;
+}

package/dist/packages/runtime/src/sessions/file-system-session-coordinator.js

@@ -0,0 +1,132 @@
+import { readJsonFile, writeJsonFile } from "../shared/json-file";
+export class FileSystemSessionCoordinator {
+    workspace;
+    sessionClient;
+    constructor(workspace, sessionClient) {
+        this.workspace = workspace;
+        this.sessionClient = sessionClient;
+    }
+    async getRelevantSession(workflowId) {
+        const sessions = await this.loadSessions(workflowId);
+        const relevant = [...sessions]
+            .reverse()
+            .find((session) => !session.archived);
+        if (!relevant) {
+            return {
+                sessionId: null,
+                relevant: false,
+                status: "missing",
+                phaseMatches: false,
+            };
+        }
+        const status = await this.sessionClient.getSessionStatus(relevant.sessionId);
+        return {
+            sessionId: relevant.sessionId,
+            relevant: true,
+            status,
+            phaseMatches: true,
+        };
+    }
+    async ensureSession(workflowId, phase, preferredSessionId) {
+        const sessions = await this.loadSessions(workflowId);
+        if (preferredSessionId && (phase === "develop" || phase === "review" || phase === "test")) {
+            const foreground = sessions.find((session) => session.sessionId === preferredSessionId);
+            if (foreground) {
+                const next = sessions.map((session) => session.sessionId === preferredSessionId
+                    ? {
+                        ...session,
+                        workflowId,
+                        phase,
+                        archived: false,
+                        isForegroundPreferred: true,
+                    }
+                    : session);
+                await this.saveSessions(workflowId, next);
+                return preferredSessionId;
+            }
+            const createdForeground = {
+                sessionId: preferredSessionId,
+                workflowId,
+                phase,
+                createdAt: new Date().toISOString(),
+                isForegroundPreferred: true,
+                status: "idle",
+                title: `${workflowId}:${phase}`,
+            };
+            sessions.push(createdForeground);
+            await this.saveSessions(workflowId, sessions);
+            return preferredSessionId;
+        }
+        const existing = [...sessions]
+            .reverse()
+            .find((session) => !session.archived && session.phase === phase);
+        if (existing) {
+            return existing.sessionId;
+        }
+        const sessionTitle = `${workflowId}:${phase}`;
+        const created = await this.sessionClient.createSession({
+            workflowId,
+            phase,
+            title: sessionTitle,
+        });
+        const next = {
+            sessionId: created.sessionId,
+            workflowId,
+            phase,
+            createdAt: new Date().toISOString(),
+            status: "idle",
+            title: sessionTitle,
+        };
+        sessions.push(next);
+        await this.saveSessions(workflowId, sessions);
+        return next.sessionId;
+    }
+    async inject(workflowId, sessionId, prompt) {
+        const stored = await this.getStoredSession(workflowId, sessionId);
+        if (stored) {
+            await this.sessionClient.ensureSessionReady(sessionId, stored.title || `${workflowId}:${stored.phase}`);
+        }
+        const injectResult = await this.sessionClient.injectPrompt({
+            sessionId,
+            prompt,
+        });
+        const sessions = await this.loadSessions(workflowId);
+        const next = sessions.map((session) => {
+            if (session.sessionId !== sessionId) {
+                return session;
+            }
+            return {
+                ...session,
+                status: injectResult.statusBefore === "failed" ? "failed" : "running",
+                lastPrompt: prompt,
+                lastDispatchMode: injectResult.dispatchMode,
+                lastStatusBeforeDispatch: injectResult.statusBefore,
+            };
+        });
+        await this.saveSessions(workflowId, next);
+    }
+    async archiveIrrelevantSessions(workflowId, phase) {
+        const sessions = await this.loadSessions(workflowId);
+        const next = sessions.map((session) => ({
+            ...session,
+            archived: session.phase !== phase,
+        }));
+        await this.saveSessions(workflowId, next);
+    }
+    async getStoredSession(workflowId, sessionId) {
+        const sessions = await this.loadSessions(workflowId);
+        return sessions.find((session) => session.sessionId === sessionId) ?? null;
+    }
+    async *streamEvents(session) {
+        for await (const event of this.sessionClient.streamEvents(session.sessionId)) {
+            yield event;
+        }
+    }
+    async loadSessions(workflowId) {
+        const data = await readJsonFile(this.workspace.sessionsFile(workflowId));
+        return data?.sessions ?? [];
+    }
+    async saveSessions(workflowId, sessions) {
+        await writeJsonFile(this.workspace.sessionsFile(workflowId), { sessions });
+    }
+}

package/dist/packages/runtime/src/sessions/session-activity-monitor.d.ts

@@ -0,0 +1,22 @@
+import type { TickScheduler } from "../scheduling/tick-scheduler";
+import type { WorkflowStateStore } from "../state/workflow-state-store";
+import type { SessionCoordinator } from "./session-coordinator";
+export interface SessionActivityMonitor {
+    start(workflowId: string): Promise<void>;
+    stop(workflowId: string): Promise<void>;
+}
+export declare class DefaultSessionActivityMonitor implements SessionActivityMonitor {
+    private readonly scopeKey;
+    private readonly stateStore;
+    private readonly sessionCoordinator;
+    private readonly tickScheduler;
+    private static readonly activeControllers;
+    private readonly running;
+    constructor(scopeKey: string, stateStore: WorkflowStateStore, sessionCoordinator: SessionCoordinator, tickScheduler: TickScheduler);
+    start(workflowId: string): Promise<void>;
+    stop(workflowId: string): Promise<void>;
+    private runLoop;
+    private keyFor;
+    private sleep;
+    private requestTickSafely;
+}

package/dist/packages/runtime/src/sessions/session-activity-monitor.js

@@ -0,0 +1,112 @@
+export class DefaultSessionActivityMonitor {
+    scopeKey;
+    stateStore;
+    sessionCoordinator;
+    tickScheduler;
+    static activeControllers = new Map();
+    running = new Map();
+    constructor(scopeKey, stateStore, sessionCoordinator, tickScheduler) {
+        this.scopeKey = scopeKey;
+        this.stateStore = stateStore;
+        this.sessionCoordinator = sessionCoordinator;
+        this.tickScheduler = tickScheduler;
+    }
+    async start(workflowId) {
+        const monitorKey = this.keyFor(workflowId);
+        if (this.running.has(monitorKey)) {
+            return;
+        }
+        const active = DefaultSessionActivityMonitor.activeControllers.get(monitorKey);
+        if (active) {
+            active.abort();
+        }
+        const controller = new AbortController();
+        this.running.set(monitorKey, controller);
+        DefaultSessionActivityMonitor.activeControllers.set(monitorKey, controller);
+        void this.runLoop(workflowId, monitorKey, controller.signal);
+    }
+    async stop(workflowId) {
+        const monitorKey = this.keyFor(workflowId);
+        const controller = this.running.get(monitorKey);
+        if (!controller) {
+            return;
+        }
+        controller.abort();
+        this.running.delete(monitorKey);
+        if (DefaultSessionActivityMonitor.activeControllers.get(monitorKey) === controller) {
+            DefaultSessionActivityMonitor.activeControllers.delete(monitorKey);
+        }
+    }
+    async runLoop(workflowId, monitorKey, signal) {
+        try {
+            while (!signal.aborted) {
+                const workflow = await this.stateStore.getWorkflow(workflowId);
+                if (!workflow?.activeSessionId) {
+                    await this.sleep(100, signal);
+                    continue;
+                }
+                const coordinator = this.sessionCoordinator;
+                const stored = coordinator.getStoredSession
+                    ? await coordinator.getStoredSession(workflowId, workflow.activeSessionId)
+                    : null;
+                if (!stored) {
+                    await this.sleep(100, signal);
+                    continue;
+                }
+                for await (const event of this.sessionCoordinator.streamEvents(stored)) {
+                    if (signal.aborted) {
+                        return;
+                    }
+                    if (event.type === "session.idle") {
+                        const shouldStop = await this.requestTickSafely(workflowId, "session idle");
+                        if (shouldStop) {
+                            return;
+                        }
+                    }
+                    if (event.type === "session.error") {
+                        const shouldStop = await this.requestTickSafely(workflowId, "session failed");
+                        if (shouldStop) {
+                            return;
+                        }
+                    }
+                }
+            }
+        }
+        finally {
+            this.running.delete(monitorKey);
+            const active = DefaultSessionActivityMonitor.activeControllers.get(monitorKey);
+            if (active && active.signal === signal) {
+                DefaultSessionActivityMonitor.activeControllers.delete(monitorKey);
+            }
+        }
+    }
+    keyFor(workflowId) {
+        return `${this.scopeKey}::${workflowId}`;
+    }
+    async sleep(ms, signal) {
+        await new Promise((resolve) => {
+            const timeout = setTimeout(() => resolve(), ms);
+            signal.addEventListener("abort", () => {
+                clearTimeout(timeout);
+                resolve();
+            }, { once: true });
+        });
+    }
+    async requestTickSafely(workflowId, reason) {
+        try {
+            await this.tickScheduler.requestTick(workflowId, reason);
+            return false;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (message.includes("Workflow not found")
+                || message.includes("Workflow state not found")
+                || message.includes("Runtime state not found")
+                || message.includes("ENOENT")
+                || message.includes("EINVAL")) {
+                return true;
+            }
+            throw error;
+        }
+    }
+}

package/dist/packages/runtime/src/sessions/session-coordinator.d.ts

@@ -0,0 +1,24 @@
+import type { Phase } from "../../../core/src/state/phase";
+import type { RelevantSessionState } from "../../../core/src/transitions/phase-transition";
+import type { SessionEvent } from "../../../adapters/opencode/src/opencode-session-client";
+export interface SessionDescriptor {
+    sessionId: string;
+    workflowId: string;
+    phase: Phase;
+    createdAt: string;
+    archived?: boolean;
+    isForegroundPreferred?: boolean;
+    status: "running" | "idle" | "failed";
+    title?: string;
+    lastPrompt?: string;
+    lastDispatchMode?: string;
+    lastStatusBeforeDispatch?: "running" | "idle" | "failed" | "missing";
+}
+export interface SessionCoordinator {
+    getRelevantSession(workflowId: string): Promise<RelevantSessionState>;
+    ensureSession(workflowId: string, phase: Phase, preferredSessionId?: string | null): Promise<string>;
+    inject(workflowId: string, sessionId: string, prompt: string): Promise<void>;
+    archiveIrrelevantSessions(workflowId: string, phase: Phase): Promise<void>;
+    getStoredSession(workflowId: string, sessionId: string): Promise<SessionDescriptor | null>;
+    streamEvents(session: SessionDescriptor): AsyncIterable<SessionEvent>;
+}

package/dist/packages/runtime/src/sessions/session-coordinator.js

@@ -0,0 +1 @@
+export {};

package/dist/packages/runtime/src/shared/json-file.d.ts

@@ -0,0 +1,2 @@
+export declare function readJsonFile<T>(filePath: string): Promise<T | null>;
+export declare function writeJsonFile(filePath: string, value: unknown): Promise<void>;

package/dist/packages/runtime/src/shared/json-file.js

@@ -0,0 +1,19 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+export async function readJsonFile(filePath) {
+    try {
+        const raw = await readFile(filePath, "utf8");
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message.includes("ENOENT")) {
+            return null;
+        }
+        throw error;
+    }
+}
+export async function writeJsonFile(filePath, value) {
+    await mkdir(dirname(filePath), { recursive: true });
+    await writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}

package/dist/packages/runtime/src/state/file-system-human-action-store.d.ts

@@ -0,0 +1,15 @@
+import type { HumanAction } from "../../../core/src/human-actions/human-action";
+import type { HumanActionRecord } from "../../../core/src/human-actions/human-action-record";
+import type { WorkflowWorkspace } from "../workspace/workflow-workspace";
+import type { HumanActionStore } from "./human-action-store";
+export declare class FileSystemHumanActionStore implements HumanActionStore {
+    private readonly workspace;
+    constructor(workspace: WorkflowWorkspace);
+    create(action: HumanAction): Promise<HumanActionRecord>;
+    getCurrent(workflowId: string): Promise<HumanActionRecord | null>;
+    private updateStatus;
+    markPresented(actionId: string): Promise<void>;
+    markResponded(actionId: string): Promise<void>;
+    markConsumed(actionId: string): Promise<void>;
+    private findByActionId;
+}

package/dist/packages/runtime/src/state/file-system-human-action-store.js

@@ -0,0 +1,69 @@
+import { readdir } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { readJsonFile, writeJsonFile } from "../shared/json-file";
+export class FileSystemHumanActionStore {
+    workspace;
+    constructor(workspace) {
+        this.workspace = workspace;
+    }
+    async create(action) {
+        const record = {
+            id: randomUUID(),
+            workflowId: action.workflowId,
+            action,
+            status: "pending",
+            createdAt: new Date().toISOString(),
+        };
+        await writeJsonFile(this.workspace.humanActionFile(action.workflowId), record);
+        return record;
+    }
+    async getCurrent(workflowId) {
+        return readJsonFile(this.workspace.humanActionFile(workflowId));
+    }
+    async updateStatus(actionId, status) {
+        const current = await this.findByActionId(actionId);
+        if (!current) {
+            throw new Error(`Human action not found: ${actionId}`);
+        }
+        const next = {
+            ...current,
+            status,
+        };
+        if (status === "responded" || status === "consumed") {
+            next.respondedAt = new Date().toISOString();
+        }
+        else if (current.respondedAt) {
+            next.respondedAt = current.respondedAt;
+        }
+        await writeJsonFile(this.workspace.humanActionFile(current.workflowId), next);
+    }
+    async markPresented(actionId) {
+        await this.updateStatus(actionId, "presented");
+    }
+    async markResponded(actionId) {
+        await this.updateStatus(actionId, "responded");
+    }
+    async markConsumed(actionId) {
+        await this.updateStatus(actionId, "consumed");
+    }
+    async findByActionId(actionId) {
+        const workflowsDir = this.workspace.workflowsRoot();
+        let workflowIds = [];
+        try {
+            workflowIds = await readdir(workflowsDir);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (!message.includes("ENOENT")) {
+                throw error;
+            }
+        }
+        for (const workflowId of workflowIds) {
+            const current = await this.getCurrent(workflowId);
+            if (current?.id === actionId) {
+                return current;
+            }
+        }
+        return null;
+    }
+}

package/dist/packages/runtime/src/state/file-system-workflow-state-store.d.ts

@@ -0,0 +1,15 @@
+import type { WorkflowRuntimeState } from "../../../core/src/state/workflow-runtime-state";
+import type { WorkflowState } from "../../../core/src/state/workflow-state";
+import type { WorkflowWorkspace } from "../workspace/workflow-workspace";
+import type { WorkflowStateStore } from "./workflow-state-store";
+export declare class FileSystemWorkflowStateStore implements WorkflowStateStore {
+    private readonly workspace;
+    constructor(workspace: WorkflowWorkspace);
+    listWorkflows(): Promise<WorkflowState[]>;
+    getWorkflow(workflowId: string): Promise<WorkflowState | null>;
+    saveWorkflow(state: WorkflowState): Promise<void>;
+    updateWorkflow(workflowId: string, patch: Partial<WorkflowState>): Promise<WorkflowState>;
+    getRuntime(workflowId: string): Promise<WorkflowRuntimeState | null>;
+    saveRuntime(state: WorkflowRuntimeState): Promise<void>;
+    updateRuntime(workflowId: string, patch: Partial<WorkflowRuntimeState>): Promise<WorkflowRuntimeState>;
+}

package/dist/packages/runtime/src/state/file-system-workflow-state-store.js

@@ -0,0 +1,59 @@
+import { readdir } from "node:fs/promises";
+import { readJsonFile, writeJsonFile } from "../shared/json-file";
+export class FileSystemWorkflowStateStore {
+    workspace;
+    constructor(workspace) {
+        this.workspace = workspace;
+    }
+    async listWorkflows() {
+        try {
+            const workflowIds = await readdir(this.workspace.workflowsRoot());
+            const items = await Promise.all(workflowIds.map((workflowId) => this.getWorkflow(workflowId)));
+            return items.filter((item) => item !== null);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (message.includes("ENOENT")) {
+                return [];
+            }
+            throw error;
+        }
+    }
+    async getWorkflow(workflowId) {
+        return readJsonFile(this.workspace.workflowStateFile(workflowId));
+    }
+    async saveWorkflow(state) {
+        await writeJsonFile(this.workspace.workflowStateFile(state.workflowId), state);
+    }
+    async updateWorkflow(workflowId, patch) {
+        const current = await this.getWorkflow(workflowId);
+        if (!current) {
+            throw new Error(`Workflow state not found: ${workflowId}`);
+        }
+        const next = {
+            ...current,
+            ...patch,
+            updatedAt: new Date().toISOString(),
+        };
+        await this.saveWorkflow(next);
+        return next;
+    }
+    async getRuntime(workflowId) {
+        return readJsonFile(this.workspace.workflowRuntimeStateFile(workflowId));
+    }
+    async saveRuntime(state) {
+        await writeJsonFile(this.workspace.workflowRuntimeStateFile(state.workflowId), state);
+    }
+    async updateRuntime(workflowId, patch) {
+        const current = await this.getRuntime(workflowId);
+        if (!current) {
+            throw new Error(`Workflow runtime state not found: ${workflowId}`);
+        }
+        const next = {
+            ...current,
+            ...patch,
+        };
+        await this.saveRuntime(next);
+        return next;
+    }
+}

package/dist/packages/runtime/src/state/human-action-service.d.ts

@@ -0,0 +1,21 @@
+import type { FileSystemArtifactEvaluator } from "../artifacts/file-system-artifact-evaluator";
+import type { WorkflowEventStore } from "../events/workflow-event-store";
+import type { TickScheduler } from "../scheduling/tick-scheduler";
+import type { HumanActionStore } from "./human-action-store";
+import type { WorkflowStateStore } from "./workflow-state-store";
+export interface HumanActionService {
+    answer(workflowId: string, answers: Record<string, string>): Promise<void>;
+    approve(workflowId: string): Promise<void>;
+    resume(workflowId: string): Promise<void>;
+}
+export declare class DefaultHumanActionService implements HumanActionService {
+    private readonly humanActionStore;
+    private readonly stateStore;
+    private readonly artifactEvaluator;
+    private readonly tickScheduler;
+    private readonly eventStore;
+    constructor(humanActionStore: HumanActionStore, stateStore: WorkflowStateStore, artifactEvaluator: FileSystemArtifactEvaluator, tickScheduler: TickScheduler, eventStore: WorkflowEventStore);
+    answer(workflowId: string, answers: Record<string, string>): Promise<void>;
+    approve(workflowId: string): Promise<void>;
+    resume(workflowId: string): Promise<void>;
+}