@dotcontext/mcp 0.9.0

package/dist/services/workflow/workflowService.js

@@ -0,0 +1,698 @@
+"use strict";
+/**
+ * PREVC Workflow Service
+ *
+ * High-level service for managing PREVC workflows via CLI and MCP.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowService = exports.HarnessWorkflowBlockedError = void 0;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs-extra"));
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const workflow_1 = require("../../workflow");
+const harness_1 = require("../harness");
+const exec = (0, util_1.promisify)(child_process_1.exec);
+class HarnessWorkflowBlockedError extends Error {
+    constructor(message, reasons, harnessStatus) {
+        super(message);
+        this.reasons = reasons;
+        this.harnessStatus = harnessStatus;
+        this.name = 'HarnessWorkflowBlockedError';
+    }
+}
+exports.HarnessWorkflowBlockedError = HarnessWorkflowBlockedError;
+/**
+ * PREVC Workflow Service
+ */
+class WorkflowService {
+    constructor(repoPath, deps = {}) {
+        const resolvedPath = path.resolve(repoPath);
+        this.repoPath = path.basename(resolvedPath) === '.context'
+            ? path.dirname(resolvedPath)
+            : resolvedPath;
+        this.contextPath = path.basename(resolvedPath) === '.context'
+            ? resolvedPath
+            : path.join(resolvedPath, '.context');
+        this.orchestrator = new workflow_1.PrevcOrchestrator(this.contextPath);
+        this.collaborationManager = new workflow_1.CollaborationManager();
+        this.runtimeStateService = new harness_1.HarnessRuntimeStateService({ repoPath: this.repoPath });
+        this.sensorCatalogService = new harness_1.HarnessSensorCatalogService({
+            repoPath: this.repoPath,
+            contextPath: this.contextPath,
+        });
+        this.sensorsService = new harness_1.HarnessSensorsService({ stateService: this.runtimeStateService });
+        this.taskContractsService = new harness_1.HarnessTaskContractsService({
+            repoPath: this.repoPath,
+            stateService: this.runtimeStateService,
+        });
+        this.policyService = new harness_1.HarnessPolicyService({ repoPath: this.repoPath });
+        this.workflowStateService = new harness_1.HarnessWorkflowStateService({ contextPath: this.contextPath });
+        this.deps = deps;
+        this.registerDefaultSensors();
+    }
+    /**
+     * Create a WorkflowService with the given repository path
+     */
+    static async create(repoPath = process.cwd(), deps = {}) {
+        return new WorkflowService(repoPath, deps);
+    }
+    /**
+     * Check if a workflow exists
+     */
+    async hasWorkflow() {
+        return this.orchestrator.hasWorkflow();
+    }
+    /**
+     * Initialize a new workflow
+     */
+    async init(options) {
+        await this.policyService.authorize({
+            tool: 'workflow',
+            action: 'init',
+            risk: options.archivePrevious ? 'high' : 'medium',
+            metadata: {
+                name: options.name,
+                scale: options.scale,
+            },
+        });
+        // Ensure .context directory exists
+        await fs.ensureDir(this.contextPath);
+        await fs.ensureDir(path.join(this.contextPath, 'workflow'));
+        // Determine scale
+        let scale;
+        if (typeof options.scale === 'string') {
+            scale = (0, workflow_1.getScaleFromName)(options.scale) ?? workflow_1.ProjectScale.MEDIUM;
+        }
+        else if (typeof options.scale === 'number') {
+            scale = options.scale;
+        }
+        else {
+            // Auto-detect based on context
+            const context = {
+                name: options.name,
+                description: options.description || options.name,
+                files: options.files,
+            };
+            const { detectProjectScale } = await Promise.resolve().then(() => __importStar(require('../../workflow')));
+            scale = detectProjectScale(context);
+        }
+        // Build settings overrides
+        const settings = options.autonomous !== undefined ||
+            options.requirePlan !== undefined ||
+            options.requireApproval !== undefined
+            ? {
+                autonomous_mode: options.autonomous,
+                require_plan: options.requirePlan,
+                require_approval: options.requireApproval,
+            }
+            : undefined;
+        // Initialize workflow
+        const status = await this.orchestrator.initWorkflowWithScale(options.name, scale, settings, options.archivePrevious);
+        await this.ensureHarnessSession(options.name, options.description);
+        this.deps.ui?.displaySuccess(`Workflow PREVC initialized: ${options.name} (Scale: ${(0, workflow_1.getScaleName)(scale)})`);
+        return status;
+    }
+    /**
+     * Get current workflow status
+     */
+    async getStatus() {
+        return this.orchestrator.getStatus();
+    }
+    /**
+     * Get workflow summary for display
+     */
+    async getSummary() {
+        return this.orchestrator.getSummary();
+    }
+    /**
+     * Get formatted status for CLI display
+     */
+    async getFormattedStatus() {
+        const summary = await this.getSummary();
+        const status = await this.getStatus();
+        const harness = await this.getHarnessStatus();
+        const lines = [];
+        lines.push(`📋 Workflow: ${summary.name}`);
+        lines.push(`📊 Scale: ${(0, workflow_1.getScaleName)(summary.scale)}`);
+        lines.push(`📍 Current Phase: ${workflow_1.PHASE_NAMES_PT[summary.currentPhase]} (${summary.currentPhase})`);
+        lines.push(`📈 Progress: ${summary.progress.percentage}% (${summary.progress.completed}/${summary.progress.total} phases)`);
+        lines.push('');
+        lines.push('Phases:');
+        for (const [phase, phaseStatus] of Object.entries(status.phases)) {
+            const emoji = phaseStatus.status === 'completed' ? '✅' :
+                phaseStatus.status === 'in_progress' ? '🔄' :
+                    phaseStatus.status === 'skipped' ? '⏭️' : '⏸️';
+            const phaseName = workflow_1.PHASE_NAMES_PT[phase];
+            lines.push(`  ${emoji} ${phase}: ${phaseName} - ${phaseStatus.status}`);
+        }
+        if (harness) {
+            const activeTask = harness.binding.activeTaskId
+                ? harness.taskContracts.find((task) => task.id === harness.binding.activeTaskId) || null
+                : null;
+            lines.push('');
+            lines.push('Harness:');
+            lines.push(`  🧵 Session: ${harness.session.name} (${harness.session.status})`);
+            lines.push(`  📌 Tasks: ${harness.taskContracts.length}`);
+            lines.push(`  🤝 Handoffs: ${harness.handoffs.length}`);
+            lines.push(`  🧪 Sensors: ${harness.sensorRuns.length}`);
+            if (activeTask) {
+                lines.push(`  🎯 Active Task: ${activeTask.title} (${activeTask.status})`);
+            }
+            else if (harness.taskContracts.length > 0) {
+                lines.push('  🎯 Active Task: none');
+            }
+            if (harness.completionCheck.blocked) {
+                lines.push('  🚫 Completion checks blocked');
+                for (const reason of harness.completionCheck.reasons) {
+                    lines.push(`    - ${reason}`);
+                }
+            }
+        }
+        if (summary.isComplete) {
+            lines.push('');
+            lines.push('✨ Workflow complete!');
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Advance to the next phase
+     */
+    async advance(outputs, options) {
+        const currentPhase = await this.orchestrator.getCurrentPhase();
+        if (!options?.force) {
+            const approval = await this.getApproval();
+            await this.policyService.authorize({
+                tool: 'workflow',
+                action: 'advance',
+                risk: 'high',
+                approval: approval?.plan_approved
+                    ? { approvedBy: approval.approved_by, note: approval.approval_notes }
+                    : undefined,
+            });
+            const harnessStatus = await this.getHarnessStatus();
+            if (harnessStatus?.completionCheck.blocked) {
+                throw new HarnessWorkflowBlockedError('Harness completion checks blocked workflow advance.', harnessStatus.completionCheck.reasons, harnessStatus);
+            }
+        }
+        const nextPhase = await this.orchestrator.completePhase(outputs, options);
+        const binding = await this.requireHarnessBinding();
+        if (nextPhase) {
+            const session = await this.runtimeStateService.checkpointSession(binding.sessionId, {
+                note: `Advanced workflow phase ${currentPhase} -> ${nextPhase}`,
+                data: { from: currentPhase, to: nextPhase, outputs },
+            });
+            binding.updatedAt = session.updatedAt;
+            await this.saveHarnessBinding(binding);
+            this.deps.ui?.displaySuccess(`Advanced from ${workflow_1.PHASE_NAMES_PT[currentPhase]} to ${workflow_1.PHASE_NAMES_PT[nextPhase]}`);
+        }
+        else {
+            const session = await this.runtimeStateService.completeSession(binding.sessionId, 'Workflow completed');
+            binding.updatedAt = session.updatedAt;
+            await this.saveHarnessBinding(binding);
+            this.deps.ui?.displaySuccess('Workflow completed!');
+        }
+        return nextPhase;
+    }
+    /**
+     * Check workflow gates for the current phase transition
+     */
+    async checkGates() {
+        return this.orchestrator.checkGates();
+    }
+    /**
+     * Set workflow settings
+     */
+    async setSettings(settings) {
+        const isHighRisk = typeof settings.autonomous_mode === 'boolean' ||
+            typeof settings.require_approval === 'boolean';
+        await this.policyService.authorize({
+            tool: 'workflow',
+            action: 'setSettings',
+            risk: isHighRisk ? 'high' : 'medium',
+            metadata: settings,
+        });
+        return this.orchestrator.setSettings(settings);
+    }
+    /**
+     * Get workflow settings
+     */
+    async getSettings() {
+        return this.orchestrator.getSettings();
+    }
+    listAvailableSensors() {
+        return this.sensorsService.listSensors().map((sensor) => ({
+            id: sensor.id,
+            name: sensor.name,
+            description: sensor.description,
+        }));
+    }
+    /**
+     * Enable or disable autonomous mode
+     */
+    async setAutonomousMode(enabled) {
+        await this.policyService.authorize({
+            tool: 'workflow',
+            action: 'setAutonomousMode',
+            risk: 'high',
+            metadata: { enabled },
+        });
+        return this.orchestrator.setSettings({ autonomous_mode: enabled });
+    }
+    /**
+     * Mark that a plan has been created/linked
+     */
+    async markPlanCreated(planSlug) {
+        await this.policyService.authorize({
+            tool: 'workflow',
+            action: 'markPlanCreated',
+            risk: 'medium',
+            metadata: { planSlug },
+        });
+        return this.orchestrator.markPlanCreated(planSlug);
+    }
+    /**
+     * Approve the plan
+     */
+    async approvePlan(approver, notes) {
+        await this.policyService.authorize({
+            tool: 'workflow',
+            action: 'approvePlan',
+            risk: 'high',
+            approval: { approvedBy: String(approver), note: notes },
+            metadata: { approver, notes },
+        });
+        return this.orchestrator.approvePlan(approver, notes);
+    }
+    /**
+     * Get approval status
+     */
+    async getApproval() {
+        return this.orchestrator.getApproval();
+    }
+    /**
+     * Perform a handoff between agents
+     */
+    async handoff(from, to, artifacts) {
+        const handoffRisk = artifacts.some((artifactPath) => /secret|token|key|password/i.test(artifactPath))
+            ? 'high'
+            : 'medium';
+        await this.policyService.authorize({
+            tool: 'workflow',
+            action: 'handoff',
+            paths: artifacts,
+            risk: handoffRisk,
+            metadata: {
+                from,
+                to,
+                artifactCount: artifacts.length,
+            },
+        });
+        await this.orchestrator.handoff(from, to, artifacts);
+        const binding = await this.requireHarnessBinding();
+        for (const artifactPath of artifacts) {
+            await this.runtimeStateService.addArtifact(binding.sessionId, {
+                name: artifactPath,
+                kind: 'file',
+                path: artifactPath,
+                metadata: { from, to, source: 'workflow.handoff' },
+            });
+        }
+        await this.taskContractsService.createHandoffContract({
+            from,
+            to,
+            sessionId: binding.sessionId,
+            taskId: binding.activeTaskId,
+            artifacts,
+            evidence: [],
+        });
+        binding.updatedAt = new Date().toISOString();
+        await this.saveHarnessBinding(binding);
+        this.deps.ui?.displaySuccess(`Handoff: ${from} → ${to}`);
+    }
+    /**
+     * Get orchestration guidance for a phase
+     */
+    async getPhaseOrchestration(phase) {
+        return this.orchestrator.getPhaseOrchestration(phase);
+    }
+    /**
+     * Get next agent suggestion after a handoff
+     */
+    getNextAgentSuggestion(currentAgent) {
+        return this.orchestrator.getNextAgentSuggestion(currentAgent);
+    }
+    /**
+     * Start a collaboration session
+     */
+    async startCollaboration(topic, participants) {
+        const session = this.collaborationManager.createSession(topic, participants);
+        await session.start(topic, participants);
+        this.deps.ui?.displaySuccess(`Collaboration started: ${topic}`);
+        this.deps.ui?.displayInfo(`Participants: ${session.getParticipantNames().join(', ')}`);
+        return session;
+    }
+    /**
+     * Add a contribution to a collaboration session
+     */
+    contributeToCollaboration(sessionId, role, message) {
+        const session = this.collaborationManager.getSession(sessionId);
+        if (!session) {
+            throw new Error(`Session not found: ${sessionId}`);
+        }
+        session.contribute(role, message);
+    }
+    /**
+     * End a collaboration session and get synthesis
+     */
+    async endCollaboration(sessionId) {
+        return this.collaborationManager.endSession(sessionId);
+    }
+    /**
+     * Get recommended next actions
+     */
+    async getRecommendedActions() {
+        return this.orchestrator.getRecommendedActions();
+    }
+    /**
+     * Check if workflow is complete
+     */
+    async isComplete() {
+        return this.orchestrator.isComplete();
+    }
+    /**
+     * Update the current task
+     */
+    async updateTask(task) {
+        await this.policyService.authorize({
+            tool: 'workflow',
+            action: 'updateTask',
+            risk: 'medium',
+            metadata: { task },
+        });
+        await this.orchestrator.updateCurrentTask(task);
+    }
+    /**
+     * Start a role in the current phase
+     */
+    async startRole(role) {
+        await this.policyService.authorize({
+            tool: 'workflow',
+            action: 'startRole',
+            risk: 'medium',
+            metadata: { role },
+        });
+        await this.orchestrator.startRole(role);
+        this.deps.ui?.displaySuccess(`Started role: ${workflow_1.ROLE_DISPLAY_NAMES[role]}`);
+    }
+    /**
+     * Complete a role's work
+     */
+    async completeRole(role, outputs) {
+        await this.policyService.authorize({
+            tool: 'workflow',
+            action: 'completeRole',
+            paths: outputs,
+            risk: outputs.some((output) => /secret|token|key|password/i.test(output)) ? 'high' : 'medium',
+            metadata: {
+                role,
+                outputCount: outputs.length,
+            },
+        });
+        await this.orchestrator.completeRole(role, outputs);
+        this.deps.ui?.displaySuccess(`Completed role: ${workflow_1.ROLE_DISPLAY_NAMES[role]}`);
+    }
+    async getHarnessStatus() {
+        if (!(await this.hasWorkflow())) {
+            return null;
+        }
+        const summary = await this.getSummary();
+        const binding = await this.ensureHarnessSession(summary.name);
+        const session = await this.runtimeStateService.getSession(binding.sessionId);
+        const allSensorRuns = await this.sensorsService.getSessionSensorRuns(binding.sessionId);
+        const policyRules = await this.policyService.listRules();
+        const latestRuns = new Map();
+        for (const run of allSensorRuns) {
+            const current = latestRuns.get(run.sensorId);
+            if (!current || current.createdAt < run.createdAt) {
+                latestRuns.set(run.sensorId, run);
+            }
+        }
+        const sensorRuns = Array.from(latestRuns.values()).sort((a, b) => a.sensorId.localeCompare(b.sensorId));
+        const taskContracts = (await this.taskContractsService.listTaskContracts())
+            .filter((contract) => contract.sessionId === binding.sessionId);
+        const handoffs = (await this.taskContractsService.listHandoffContracts())
+            .filter((handoff) => handoff.sessionId === binding.sessionId);
+        const activeTask = binding.activeTaskId
+            ? taskContracts.find((contract) => contract.id === binding.activeTaskId) ?? null
+            : null;
+        const taskCompletion = activeTask
+            ? await this.taskContractsService.evaluateTaskCompletion(activeTask.id, binding.sessionId)
+            : null;
+        const backpressure = this.sensorsService.evaluateBackpressure(sensorRuns, { requireEvidence: true });
+        const reasons = [
+            ...backpressure.reasons,
+            ...(taskCompletion?.blockingFindings || []),
+        ];
+        return {
+            binding,
+            session,
+            availableSensors: this.listAvailableSensors(),
+            sensorRuns,
+            taskContracts,
+            handoffs,
+            policyRules: policyRules.length,
+            completionCheck: {
+                blocked: reasons.length > 0,
+                reasons,
+                taskCompletion: taskCompletion ? {
+                    canComplete: taskCompletion.canComplete,
+                    missingSensors: taskCompletion.missingSensors,
+                    missingArtifacts: taskCompletion.missingArtifacts,
+                    blockingFindings: taskCompletion.blockingFindings,
+                } : null,
+            },
+        };
+    }
+    async checkpointHarnessSession(note, data, artifactIds, pause) {
+        const binding = await this.requireHarnessBinding();
+        await this.policyService.authorize({
+            tool: 'workflow',
+            action: 'checkpoint',
+            risk: pause ? 'high' : 'medium',
+            metadata: {
+                note,
+                pause: Boolean(pause),
+                artifactCount: artifactIds?.length ?? 0,
+            },
+        });
+        const session = await this.runtimeStateService.checkpointSession(binding.sessionId, {
+            note,
+            data,
+            artifactIds,
+            pause,
+        });
+        binding.updatedAt = session.updatedAt;
+        await this.saveHarnessBinding(binding);
+        return { binding, session };
+    }
+    async recordHarnessArtifact(input) {
+        const binding = await this.requireHarnessBinding();
+        await this.policyService.authorize({
+            tool: 'workflow',
+            action: 'recordArtifact',
+            paths: input.path ? [input.path] : [input.name],
+            risk: input.path?.includes('secret') ? 'critical' : 'medium',
+            metadata: input.metadata,
+        });
+        const artifact = await this.runtimeStateService.addArtifact(binding.sessionId, input);
+        binding.updatedAt = artifact.createdAt;
+        await this.saveHarnessBinding(binding);
+        return artifact;
+    }
+    async defineHarnessTask(input) {
+        const binding = await this.requireHarnessBinding();
+        await this.policyService.authorize({
+            tool: 'workflow',
+            action: 'defineTask',
+            risk: input.requiredSensors?.includes('deploy') ? 'high' : 'medium',
+            metadata: {
+                ...input.metadata,
+                title: input.title,
+            },
+        });
+        const contract = await this.taskContractsService.createTaskContract({
+            ...input,
+            sessionId: binding.sessionId,
+            status: 'ready',
+        });
+        binding.activeTaskId = contract.id;
+        binding.updatedAt = contract.updatedAt;
+        await this.saveHarnessBinding(binding);
+        return contract;
+    }
+    async runHarnessSensors(sensorIds, metadata) {
+        const binding = await this.requireHarnessBinding();
+        const runs = [];
+        for (const sensorId of sensorIds) {
+            await this.policyService.authorize({
+                tool: 'workflow',
+                action: 'runSensors',
+                risk: sensorId === 'deploy' ? 'high' : 'medium',
+                metadata,
+            });
+            runs.push(await this.sensorsService.runSensor(sensorId, {
+                sessionId: binding.sessionId,
+                contractId: binding.activeTaskId,
+                metadata,
+            }));
+        }
+        return {
+            runs,
+            backpressure: this.sensorsService.evaluateBackpressure(runs, { requireEvidence: true }),
+        };
+    }
+    async ensureHarnessSession(workflowName, description) {
+        const existing = await this.loadHarnessBinding();
+        if (existing && existing.workflowName === workflowName) {
+            try {
+                await this.runtimeStateService.getSession(existing.sessionId);
+                return existing;
+            }
+            catch {
+                // Session was removed or became unreadable. Recreate below.
+            }
+        }
+        const session = await this.runtimeStateService.createSession({
+            name: workflowName,
+            metadata: {
+                workflow: true,
+                description,
+            },
+        });
+        const binding = {
+            workflowName,
+            sessionId: session.id,
+            createdAt: new Date().toISOString(),
+            updatedAt: session.updatedAt,
+        };
+        await this.saveHarnessBinding(binding);
+        return binding;
+    }
+    async requireHarnessBinding() {
+        const summary = await this.getSummary();
+        return this.ensureHarnessSession(summary.name);
+    }
+    async loadHarnessBinding() {
+        return this.workflowStateService.getBinding();
+    }
+    async saveHarnessBinding(binding) {
+        await this.workflowStateService.saveBinding(binding);
+    }
+    registerDefaultSensors() {
+        const definitions = this.sensorCatalogService.resolveEffectiveSensorsSync();
+        for (const definition of definitions) {
+            if (this.sensorsService.getSensor(definition.id)) {
+                continue;
+            }
+            this.sensorsService.registerSensor({
+                id: definition.id,
+                name: definition.name,
+                severity: definition.severity,
+                blocking: definition.severity === 'critical',
+                execute: async () => {
+                    if (definition.script) {
+                        const hasScript = await this.hasPackageScript(definition.script);
+                        if (!hasScript) {
+                            return {
+                                status: definition.severity === 'warning' ? 'skipped' : 'blocked',
+                                summary: `Script not available: ${definition.script}`,
+                                evidence: [`Missing package.json script: ${definition.script}`],
+                            };
+                        }
+                    }
+                    return this.executeShellSensor(definition.command, definition.name);
+                },
+            });
+        }
+    }
+    async hasPackageScript(scriptName) {
+        const packageJsonPath = path.join(this.repoPath, 'package.json');
+        if (!(await fs.pathExists(packageJsonPath))) {
+            return false;
+        }
+        const packageJson = await fs.readJson(packageJsonPath);
+        return Boolean(packageJson.scripts?.[scriptName]);
+    }
+    async executeShellSensor(command, name) {
+        try {
+            const { stdout, stderr } = await exec(command, {
+                cwd: this.repoPath,
+                timeout: 300000,
+            });
+            return {
+                status: 'passed',
+                summary: `${name} passed`,
+                evidence: [this.trimEvidence(stdout), this.trimEvidence(stderr)].filter(Boolean),
+                output: {
+                    command,
+                },
+            };
+        }
+        catch (error) {
+            return {
+                status: 'failed',
+                summary: `${name} failed`,
+                evidence: [
+                    this.trimEvidence(error?.stdout),
+                    this.trimEvidence(error?.stderr || error?.message),
+                ].filter(Boolean),
+                details: {
+                    command,
+                    exitCode: typeof error?.code === 'number' ? error.code : undefined,
+                },
+            };
+        }
+    }
+    trimEvidence(value, maxLength = 2000) {
+        if (!value) {
+            return null;
+        }
+        return value.length > maxLength ? `${value.slice(0, maxLength)}\n...[truncated]` : value;
+    }
+}
+exports.WorkflowService = WorkflowService;
+//# sourceMappingURL=workflowService.js.map