@emiliosp/pi-maestro 0.10.1 → 0.12.0

package/package.json

@@ -1,30 +1,23 @@
 {
   "name": "@emiliosp/pi-maestro",
-  "version": "0.10.1",
+  "version": "0.12.0",
   "description": "A spec-driven multiagent development workflow for Pi.",
-  "license": "MIT",
-  "type": "module",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/emiliosp/pi-maestro.git"
-  },
-  "homepage": "https://github.com/emiliosp/pi-maestro#readme",
-  "bugs": {
-    "url": "https://github.com/emiliosp/pi-maestro/issues"
-  },
   "keywords": [
-    "pi-package",
+    "orchestration",
     "pi",
     "pi-coding-agent",
-    "workflow",
+    "pi-package",
     "subagents",
-    "orchestration"
-  ],
-  "os": [
-    "darwin"
+    "workflow"
   ],
-  "engines": {
-    "node": ">=26.0.0"
+  "homepage": "https://github.com/emiliosp/pi-maestro#readme",
+  "bugs": {
+    "url": "https://github.com/emiliosp/pi-maestro/issues"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/emiliosp/pi-maestro.git"
   },
   "files": [
     "extensions/",
@@ -41,6 +34,10 @@
     "README.md",
     "LICENSE"
   ],
+  "os": [
+    "darwin"
+  ],
+  "type": "module",
   "imports": {
     "#config/*": "./src/config/*",
     "#specs/*": "./src/specs/*",
@@ -53,41 +50,46 @@
     "#ids/*": "./src/ids/*",
     "#*": "./*"
   },
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
     "typecheck": "tsc --noEmit",
     "test": "vitest run --coverage --config vitest.config.ts",
-    "check": "npm run lint:fix && npm run typecheck && npm test",
+    "check": "npm run fmt && npm run lint && npm run typecheck && npm test",
     "prepublishOnly": "npm run check",
     "publish:npm": "npm publish --access public",
-    "lint": "biome check .",
-    "lint:anti-slop": "oxlint --fix",
-    "lint:fix": "biome check --write . && npm run lint:anti-slop"
+    "fmt": "oxfmt",
+    "lint": "oxlint --fix"
   },
   "dependencies": {
     "pi-subagents": "0.78.0"
   },
-  "bundleDependencies": [
-    "pi-subagents"
-  ],
-  "peerDependencies": {
-    "@earendil-works/pi-ai": "*",
-    "@earendil-works/pi-coding-agent": "*",
-    "typebox": "*"
-  },
   "devDependencies": {
-    "@biomejs/biome": "2.5.15",
     "@earendil-works/pi-agent-core": "1.0.3",
     "@earendil-works/pi-tui": "1.0.3",
-    "@vitest/coverage-v8": "5.0.3",
     "@types/node": "26.6.4",
+    "@vitest/coverage-v8": "5.0.3",
+    "oxfmt": "0.73.0",
     "oxlint": "1.87.0",
-    "oxlint-anti-slop": "0.3.6",
+    "oxlint-anti-slop": "0.3.8",
     "typebox": "1.3.35",
     "typescript": "7.0.2",
     "vitest": "5.0.3"
   },
-  "publishConfig": {
-    "access": "public"
+  "peerDependencies": {
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*",
+    "typebox": "*"
+  },
+  "bundleDependencies": [
+    "pi-subagents"
+  ],
+  "engines": {
+    "node": ">=26.0.0"
+  },
+  "allowScripts": {
+    "fsevents@2.3.3": true
   },
   "pi": {
     "extensions": [
@@ -98,8 +100,5 @@
         "./agents"
       ]
     }
-  },
-  "allowScripts": {
-    "fsevents@2.3.3": true
   }
 }

package/src/MaestroPaths.ts

@@ -5,12 +5,15 @@
 
 import { readdir } from 'node:fs/promises';
 import { isAbsolute, relative, resolve } from 'node:path';
+
 import type { MaestroConfig } from '#config/schema.ts';
 import { isValidSpecId } from '#ids/isValidSpecId.ts';
 import { isPathStrictlyWithin } from '#utils/path-strictly-within.ts';
 
 const PATHS = {
+  PROPOSAL_FILE: 'proposal.md',
   SPEC_FILE: 'spec.md',
+  DESIGN_FILE: 'design.md',
   WORKFLOW_FILE: 'workflow.json',
   HANDOFFS_PATH: 'handoffs',
   BUILDER_HANDOFFS_PATH: 'handoffs/builder',
@@ -25,9 +28,7 @@ const AGENTS_PREFIX = {
 
 function assertSpecId(specId: string): void {
   if (!isValidSpecId(specId)) {
-    throw new Error(
-      `Invalid spec ID: "${specId}". Expected YYYYMMDD-HHmmss-<slug>.`,
-    );
+    throw new Error(`Invalid spec ID: "${specId}". Expected YYYYMMDD-HHmmss-<slug>.`);
   }
 }
 
@@ -43,9 +44,7 @@ function assertSafeRelativePrototypePath(value: string): void {
   }
 
   if (isAbsolute(value)) {
-    throw new Error(
-      'Prototype path must be relative to the prototypes directory.',
-    );
+    throw new Error('Prototype path must be relative to the prototypes directory.');
   }
 }
 
@@ -99,10 +98,18 @@ export class MaestroPaths {
     return resolve(this.projectRoot, this.specDirectoryFromRoot, specId);
   }
 
+  public getProposalFilePath(specId: string): string {
+    return resolve(this.getSpecPath(specId), PATHS.PROPOSAL_FILE);
+  }
+
   public getSpecFilePath(specId: string): string {
     return resolve(this.getSpecPath(specId), PATHS.SPEC_FILE);
   }
 
+  public getDesignFilePath(specId: string): string {
+    return resolve(this.getSpecPath(specId), PATHS.DESIGN_FILE);
+  }
+
   public getWorkflowPath(specId: string): string {
     return resolve(this.getSpecPath(specId), PATHS.WORKFLOW_FILE);
   }
@@ -119,10 +126,7 @@ export class MaestroPaths {
     return resolve(this.getSpecPath(specId), PATHS.VERIFIER_HANDOFFS_PATH);
   }
 
-  public getBuilderHandoffPath({
-    specId,
-    handoffPassNumber,
-  }: HandoffPathInput): string {
+  public getBuilderHandoffPath({ specId, handoffPassNumber }: HandoffPathInput): string {
     assertArtifactNumber(handoffPassNumber);
 
     return resolve(
@@ -131,10 +135,7 @@ export class MaestroPaths {
     );
   }
 
-  public getVerifierHandoffPath({
-    specId,
-    handoffPassNumber,
-  }: HandoffPathInput): string {
+  public getVerifierHandoffPath({ specId, handoffPassNumber }: HandoffPathInput): string {
     assertArtifactNumber(handoffPassNumber);
 
     return resolve(
@@ -144,9 +145,7 @@ export class MaestroPaths {
   }
 
   public async getActiveBuilderHandoffPath(specId: string): Promise<string> {
-    const handoffPassNumber = (
-      await readdir(this.getBuilderHandoffsPath(specId))
-    ).length;
+    const handoffPassNumber = (await readdir(this.getBuilderHandoffsPath(specId))).length;
 
     if (handoffPassNumber === 0) throw new Error('Builder handoff is missing.');
 
@@ -154,20 +153,15 @@ export class MaestroPaths {
   }
 
   public async getActiveVerifierHandoffPath(specId: string): Promise<string> {
-    const handoffPassNumber = (
-      await readdir(this.getVerifierHandoffsPath(specId))
-    ).length;
+    const handoffPassNumber = (await readdir(this.getVerifierHandoffsPath(specId))).length;
 
-    if (handoffPassNumber === 0)
-      throw new Error('Verifier handoff is missing.');
+    if (handoffPassNumber === 0) throw new Error('Verifier handoff is missing.');
 
     return this.getVerifierHandoffPath({ specId, handoffPassNumber });
   }
 
   public async getNextBuilderHandoffPath(specId: string): Promise<string> {
-    const handoffPassNumber = (
-      await readdir(this.getBuilderHandoffsPath(specId))
-    ).length;
+    const handoffPassNumber = (await readdir(this.getBuilderHandoffsPath(specId))).length;
 
     return this.getBuilderHandoffPath({
       specId,
@@ -176,9 +170,7 @@ export class MaestroPaths {
   }
 
   public async getNextVerifierHandoffPath(specId: string): Promise<string> {
-    const handoffPassNumber = (
-      await readdir(this.getVerifierHandoffsPath(specId))
-    ).length;
+    const handoffPassNumber = (await readdir(this.getVerifierHandoffsPath(specId))).length;
 
     return this.getVerifierHandoffPath({
       specId,
@@ -186,23 +178,22 @@ export class MaestroPaths {
     });
   }
 
+  public getSimplifierHandoffPath(specId: string): string {
+    return resolve(this.getSpecPath(specId), 'handoffs/simplifier/S.json');
+  }
+
   public getPrototypesPath(specId: string): string {
     return resolve(this.getSpecPath(specId), PATHS.PROTOTYPES_PATH);
   }
 
-  public getPrototypePath({
-    specId,
-    relativePath,
-  }: PrototypePathInput): string {
+  public getPrototypePath({ specId, relativePath }: PrototypePathInput): string {
     assertSafeRelativePrototypePath(relativePath);
 
     const prototypesPath = this.getPrototypesPath(specId);
     const target = resolve(prototypesPath, relativePath);
 
     if (!isPathStrictlyWithin({ parent: prototypesPath, path: target })) {
-      throw new Error(
-        'Prototype path must stay inside the prototypes directory.',
-      );
+      throw new Error('Prototype path must stay inside the prototypes directory.');
     }
 
     return target;

package/src/artifacts/builder-handoff/assertBuilderHandoff.ts

@@ -4,6 +4,7 @@
  */
 
 import { Value } from 'typebox/value';
+
 import {
   BUILDER_HANDOFF_STATUSES,
   type BuilderAcceptanceCriterion,
@@ -16,19 +17,12 @@ import { isValidSpecId } from '#ids/isValidSpecId.ts';
 const hasUniqueAcceptanceCriterionIds = (
   acceptanceCriteria: BuilderAcceptanceCriterion[],
 ): boolean =>
-  new Set(acceptanceCriteria.map((criterion) => criterion.id)).size ===
-  acceptanceCriteria.length;
+  new Set(acceptanceCriteria.map((criterion) => criterion.id)).size === acceptanceCriteria.length;
 
-const hasOnlyPassedProbes = (
-  acceptanceCriteria: BuilderAcceptanceCriterion[],
-): boolean =>
-  acceptanceCriteria.every(
-    (criterion) => criterion.probeStatus === PROBE_STATUSES.PASSED,
-  );
+const hasOnlyPassedProbes = (acceptanceCriteria: BuilderAcceptanceCriterion[]): boolean =>
+  acceptanceCriteria.every((criterion) => criterion.probeStatus === PROBE_STATUSES.PASSED);
 
-function assertBuilderHandoffSchema(
-  input: unknown,
-): asserts input is BuilderHandoff {
+function assertBuilderHandoffSchema(input: unknown): asserts input is BuilderHandoff {
   if (typeof input !== 'object' || input === null || Array.isArray(input)) {
     throw new Error('Builder handoff must be a JSON object.');
   }
@@ -77,10 +71,7 @@ export function assertBuilderHandoff(
       throw new Error('Escalation option IDs must be unique.');
     }
 
-    if (
-      escalation.recommendation !== null &&
-      !optionIds.has(escalation.recommendation.optionId)
-    ) {
+    if (escalation.recommendation !== null && !optionIds.has(escalation.recommendation.optionId)) {
       throw new Error('Escalation recommendation references unknown option.');
     }
 

package/src/artifacts/builder-handoff/schema.ts

@@ -5,6 +5,7 @@
 
 import { StringEnum } from '@earendil-works/pi-ai';
 import { type Static, Type } from 'typebox';
+
 import { SPEC_ID_PATTERN } from '#ids/isValidSpecId.ts';
 
 export const BUILDER_HANDOFF_VERSION = '1.0.0';
@@ -36,9 +37,7 @@ export const BuilderAcceptanceCriterionSchema = Type.Object(
   { additionalProperties: false },
 );
 
-export type BuilderAcceptanceCriterion = Static<
-  typeof BuilderAcceptanceCriterionSchema
->;
+export type BuilderAcceptanceCriterion = Static<typeof BuilderAcceptanceCriterionSchema>;
 
 const BuilderHandoffContentFields = {
   summary: Type.String({ minLength: 1 }),
@@ -158,6 +157,4 @@ export const BuilderHandoffSubmissionSchema = Type.Union([
   BuilderEscalationHandoffSubmissionSchema,
 ]);
 
-export type BuilderHandoffSubmissionInput = Static<
-  typeof BuilderHandoffSubmissionSchema
->;
+export type BuilderHandoffSubmissionInput = Static<typeof BuilderHandoffSubmissionSchema>;

package/src/artifacts/simplifier-handoff/assertSimplifierHandoff.ts

@@ -0,0 +1,56 @@
+/**
+ * Objective: Validate the simplifier result and its project-relative file paths.
+ * Used: Before reading or saving a simplifier handoff.
+ */
+
+import { isAbsolute, resolve } from 'node:path';
+
+import { Value } from 'typebox/value';
+
+import {
+  type SimplifierHandoff,
+  SimplifierHandoffSchema,
+} from '#artifacts/simplifier-handoff/schema.ts';
+import { isPathStrictlyWithin } from '#utils/path-strictly-within.ts';
+
+type AssertSimplifierHandoffInput<Handoff = unknown> = {
+  handoff: Handoff;
+  specId: string;
+  projectRoot: string;
+};
+
+function assertSimplifierHandoffSchema(input: unknown): asserts input is SimplifierHandoff {
+  const [error] = Value.Errors(SimplifierHandoffSchema, input);
+
+  if (error !== undefined) {
+    throw new Error(`Invalid simplifier handoff: ${error.message}.`);
+  }
+}
+
+export function assertSimplifierHandoff(
+  input: AssertSimplifierHandoffInput,
+): asserts input is AssertSimplifierHandoffInput<SimplifierHandoff> {
+  assertSimplifierHandoffSchema(input.handoff);
+  const { handoff } = input;
+
+  if (handoff.specId !== input.specId) {
+    throw new Error(
+      `Simplifier handoff spec ID mismatch: expected "${input.specId}", found "${handoff.specId}".`,
+    );
+  }
+
+  for (const file of handoff.refactoredFiles) {
+    if (
+      file.includes('\0') ||
+      isAbsolute(file) ||
+      !isPathStrictlyWithin({
+        parent: input.projectRoot,
+        path: resolve(input.projectRoot, file),
+      })
+    ) {
+      throw new Error(
+        `Refactored file path must be relative and stay inside the project root: "${file}".`,
+      );
+    }
+  }
+}

package/src/artifacts/simplifier-handoff/readSimplifierHandoff.ts

@@ -0,0 +1,29 @@
+/**
+ * Objective: Read the fixed simplifier handoff and validate its identity.
+ * Used: After foreground simplifier execution completes.
+ */
+
+import { assertSimplifierHandoff } from '#artifacts/simplifier-handoff/assertSimplifierHandoff.ts';
+import { readJsonFile } from '#utils/read-json.ts';
+
+type ReadSimplifierHandoffInput = {
+  path: string;
+  specId: string;
+  projectRoot: string;
+};
+
+export const readSimplifierHandoff = async ({
+  path,
+  specId,
+  projectRoot,
+}: ReadSimplifierHandoffInput) => {
+  const input = {
+    handoff: await readJsonFile({ path, description: 'Simplifier handoff' }),
+    specId,
+    projectRoot,
+  };
+
+  assertSimplifierHandoff(input);
+
+  return input.handoff;
+};

package/src/artifacts/simplifier-handoff/schema.ts

@@ -0,0 +1,27 @@
+/**
+ * Objective: Define the fixed simplifier result contract.
+ * Used: When a simplifier submits or Maestro reads its handoff.
+ */
+
+import { type Static, Type } from 'typebox';
+
+import { SPEC_ID_PATTERN } from '#ids/isValidSpecId.ts';
+
+export const SIMPLIFIER_HANDOFF_VERSION = '1.0.0';
+
+export const SimplifierSubmissionFields = {
+  specId: Type.String({ pattern: SPEC_ID_PATTERN.source }),
+  refactoredFiles: Type.Array(Type.String({ minLength: 1 })),
+  summary: Type.String({ minLength: 1 }),
+  notes: Type.Array(Type.String()),
+};
+
+export const SimplifierHandoffSchema = Type.Object(
+  {
+    version: Type.Literal(SIMPLIFIER_HANDOFF_VERSION),
+    ...SimplifierSubmissionFields,
+  },
+  { additionalProperties: false },
+);
+
+export type SimplifierHandoff = Static<typeof SimplifierHandoffSchema>;

package/src/artifacts/verifier-handoff/assertVerifierHandoff.ts

@@ -4,16 +4,12 @@
  */
 
 import { Value } from 'typebox/value';
+
 import { PROBE_STATUSES } from '#artifacts/builder-handoff/schema.ts';
-import {
-  type VerifierHandoff,
-  VerifierHandoffSchema,
-} from '#artifacts/verifier-handoff/schema.ts';
+import { type VerifierHandoff, VerifierHandoffSchema } from '#artifacts/verifier-handoff/schema.ts';
 import { isValidSpecId } from '#ids/isValidSpecId.ts';
 
-function assertVerifierHandoffSchema(
-  input: unknown,
-): asserts input is VerifierHandoff {
+function assertVerifierHandoffSchema(input: unknown): asserts input is VerifierHandoff {
   if (typeof input !== 'object' || input === null || Array.isArray(input)) {
     throw new Error('Verifier handoff must be a JSON object.');
   }
@@ -45,9 +41,7 @@ export function assertVerifierHandoff(
   );
 
   if (acceptanceCriterionIds.size !== handoff.acceptanceCriteria.length) {
-    throw new Error(
-      'Verifier handoff acceptance criterion IDs must be unique.',
-    );
+    throw new Error('Verifier handoff acceptance criterion IDs must be unique.');
   }
 
   const criterionIdsWithFindings = new Set<string>();

package/src/artifacts/verifier-handoff/schema.ts

@@ -4,6 +4,7 @@
  */
 
 import { type Static, Type } from 'typebox';
+
 import { BuilderAcceptanceCriterionSchema } from '#artifacts/builder-handoff/schema.ts';
 import { SPEC_ID_PATTERN } from '#ids/isValidSpecId.ts';
 
@@ -15,8 +16,7 @@ export const FINDING_SEVERITIES = {
   LOW: 'low',
 } as const;
 
-export type FindingSeverity =
-  (typeof FINDING_SEVERITIES)[keyof typeof FINDING_SEVERITIES];
+export type FindingSeverity = (typeof FINDING_SEVERITIES)[keyof typeof FINDING_SEVERITIES];
 
 const FindingSeveritySchema = Type.Union([
   Type.Literal(FINDING_SEVERITIES.HIGH),
@@ -64,10 +64,7 @@ const FindingDecisionSchema = Type.Union([
 export const VerifierFindingSchema = Type.Object(
   {
     id: Type.String({ pattern: '^F[1-9]\\d*$' }),
-    acceptanceCriterion: Type.Union([
-      Type.String({ minLength: 1 }),
-      Type.Null(),
-    ]),
+    acceptanceCriterion: Type.Union([Type.String({ minLength: 1 }), Type.Null()]),
     severity: FindingSeveritySchema,
     confidence: Type.Number({ minimum: 0, maximum: 1 }),
     summary: Type.String({ minLength: 1 }),

package/src/artifacts/verifier-handoff/writeVerifierHandoff.ts

@@ -22,9 +22,7 @@ export const writeVerifierHandoff = async ({
   const { handoff } = input;
 
   if (handoff.findings.some((finding) => finding.decision !== null)) {
-    throw new Error(
-      'New verifier handoff findings must have no owner decision.',
-    );
+    throw new Error('New verifier handoff findings must have no owner decision.');
   }
 
   await writeJson({ path, data: handoff });

package/src/config/assertConfiguration.ts

@@ -4,6 +4,7 @@
  */
 
 import { Value } from 'typebox/value';
+
 import {
   MAX_TIMEOUT_MINUTES,
   MaestroConfigInputSchema,
@@ -41,7 +42,7 @@ const formatError = (error: SchemaValidationError): string => {
     return `Invalid model identifier at "${path}". Must use "provider/model" format.`;
   }
 
-  if (path === 'builder' || path === 'verifier') {
+  if (path === 'builder' || path === 'verifier' || path === 'simplifier') {
     return `Invalid ${path} configuration: expected an object.`;
   }
 
@@ -52,9 +53,7 @@ const formatError = (error: SchemaValidationError): string => {
   return `Invalid configuration at "${path}": ${error.message}.`;
 };
 
-export function assertConfiguration(
-  input: unknown,
-): asserts input is PartialMaestroConfig {
+export function assertConfiguration(input: unknown): asserts input is PartialMaestroConfig {
   if (typeof input !== 'object' || input === null || Array.isArray(input)) {
     throw new Error('Configuration must be a JSON object.');
   }
@@ -62,9 +61,7 @@ export function assertConfiguration(
   const raw = input;
 
   if (!('version' in raw) || raw.version === undefined) {
-    throw new Error(
-      "Missing configuration version. The 'version' field is required.",
-    );
+    throw new Error("Missing configuration version. The 'version' field is required.");
   }
 
   if (typeof raw.version !== 'string') {

package/src/config/defaults.ts

@@ -3,11 +3,7 @@
  * Used: When configuration is resolved from missing or partial input.
  */
 
-import {
-  type MaestroConfig,
-  SUPPORTED_CONFIG_VERSION,
-  THINKING_LEVELS,
-} from '#config/schema.ts';
+import { type MaestroConfig, SUPPORTED_CONFIG_VERSION, THINKING_LEVELS } from '#config/schema.ts';
 
 export const DEFAULT_CONFIG_VERSION = SUPPORTED_CONFIG_VERSION;
 
@@ -21,6 +17,8 @@ export const DEFAULT_VERIFIER_MODEL = 'openai-codex/gpt-6.1-sol';
 
 export const DEFAULT_VERIFIER_THINKING = THINKING_LEVELS.HIGH;
 
+export const DEFAULT_SIMPLIFIER_MODEL = 'openai-codex/gpt-6.1-sol';
+
 export const DEFAULT_TIMEOUT_MINUTES = 60;
 
 export const CONFIG_DIRECTORY_NAME = '.pi';
@@ -37,6 +35,11 @@ export const DEFAULT_CONFIG: MaestroConfig = {
     thinking: DEFAULT_BUILDER_THINKING,
     timeoutMinutes: DEFAULT_TIMEOUT_MINUTES,
   },
+  simplifier: {
+    model: DEFAULT_SIMPLIFIER_MODEL,
+    thinking: THINKING_LEVELS.HIGH,
+    timeoutMinutes: DEFAULT_TIMEOUT_MINUTES,
+  },
   verifier: {
     model: DEFAULT_VERIFIER_MODEL,
     thinking: DEFAULT_VERIFIER_THINKING,

package/src/config/loadConfiguration.ts

@@ -5,6 +5,7 @@
 
 import { readFile, realpath } from 'node:fs/promises';
 import { isAbsolute, join, resolve } from 'node:path';
+
 import { assertConfiguration } from '#config/assertConfiguration.ts';
 import { CONFIG_FILE_PATH, DEFAULT_CONFIG } from '#config/defaults.ts';
 import type { MaestroConfig, PartialMaestroConfig } from '#config/schema.ts';
@@ -16,6 +17,7 @@ const resolveConfiguration = (input: PartialMaestroConfig): MaestroConfig => ({
   specDirectory: input.specDirectory ?? DEFAULT_CONFIG.specDirectory,
   builder: { ...DEFAULT_CONFIG.builder, ...input.builder },
   verifier: { ...DEFAULT_CONFIG.verifier, ...input.verifier },
+  simplifier: { ...DEFAULT_CONFIG.simplifier, ...input.simplifier },
 });
 
 type ResolveSpecDirectoryInput = {
@@ -23,10 +25,7 @@ type ResolveSpecDirectoryInput = {
   directory: string;
 };
 
-const resolveSpecDirectory = ({
-  projectRoot,
-  directory,
-}: ResolveSpecDirectoryInput): string => {
+const resolveSpecDirectory = ({ projectRoot, directory }: ResolveSpecDirectoryInput): string => {
   if (directory.includes('\0')) {
     throw new Error('specDirectory must not contain a null byte.');
   }
@@ -58,10 +57,7 @@ type ResolveDirectoriesInput = {
   config: MaestroConfig;
 };
 
-const resolveDirectories = ({
-  projectRoot,
-  config,
-}: ResolveDirectoriesInput): MaestroConfig => {
+const resolveDirectories = ({ projectRoot, config }: ResolveDirectoriesInput): MaestroConfig => {
   const specDirectory = resolveSpecDirectory({
     projectRoot,
     directory: config.specDirectory,
@@ -84,9 +80,7 @@ const readConfigurationFile = async (path: string): Promise<unknown> => {
   }
 };
 
-export const loadConfiguration = async (
-  cwd: string = process.cwd(),
-): Promise<MaestroConfig> => {
+export const loadConfiguration = async (cwd: string = process.cwd()): Promise<MaestroConfig> => {
   const projectRoot = await realpath(cwd);
   const targetPath = join(projectRoot, CONFIG_FILE_PATH);