@emiliosp/pi-maestro 0.11.0 → 0.13.0

package/extensions/maestro.ts

@@ -4,19 +4,14 @@
  */
 
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
+
 import { loadConfiguration } from '#config/loadConfiguration.ts';
 import { assertEnvironment } from '#maestro/checks/assertEnvironment.ts';
 import { getMaestroInstructions } from '#maestro/instructions/getMaestroInstructions.ts';
 import maestroSessionState from '#maestro/session/MaestroSessionState.ts';
 import { refreshMaestroStatus } from '#maestro/status/refreshMaestroStatus.ts';
-import {
-  CREATE_SPEC_TOOL,
-  registerCreateSpecTool,
-} from '#tools/main/create-spec.ts';
-import {
-  MARK_SPEC_READY_TOOL,
-  registerMarkSpecReadyTool,
-} from '#tools/main/mark-spec-ready.ts';
+import { CREATE_SPEC_TOOL, registerCreateSpecTool } from '#tools/main/create-spec.ts';
+import { MARK_SPEC_READY_TOOL, registerMarkSpecReadyTool } from '#tools/main/mark-spec-ready.ts';
 import {
   RESOLVE_ESCALATIONS_TOOL,
   registerResolveEscalationsTool,
@@ -25,18 +20,10 @@ import {
   RESOLVE_FINDINGS_TOOL,
   registerResolveFindingsTool,
 } from '#tools/main/resolve-findings.ts';
-import {
-  RUN_BUILDER_TOOL,
-  registerRunBuilderTool,
-} from '#tools/main/run-builder.ts';
-import {
-  RUN_SIMPLIFIER_TOOL,
-  registerRunSimplifierTool,
-} from '#tools/main/run-simplifier.ts';
-import {
-  RUN_VERIFIER_TOOL,
-  registerRunVerifierTool,
-} from '#tools/main/run-verifier.ts';
+import { RUN_BUILDER_TOOL, registerRunBuilderTool } from '#tools/main/run-builder.ts';
+import { RUN_SIMPLIFIER_TOOL, registerRunSimplifierTool } from '#tools/main/run-simplifier.ts';
+import { RUN_VERIFIER_TOOL, registerRunVerifierTool } from '#tools/main/run-verifier.ts';
+import { WORKFLOW_PHASES } from '#workflow/state/schema.ts';
 
 const MAIN_TOOL_NAMES: readonly string[] = [
   CREATE_SPEC_TOOL.NAME,
@@ -48,6 +35,19 @@ const MAIN_TOOL_NAMES: readonly string[] = [
   RUN_SIMPLIFIER_TOOL.NAME,
 ];
 
+type CompletedWorkflowResult = {
+  specId: string;
+  phase: typeof WORKFLOW_PHASES.CANDIDATE_READY;
+};
+
+const isCompletedWorkflowResult = (details: unknown): details is CompletedWorkflowResult =>
+  typeof details === 'object' &&
+  details !== null &&
+  'specId' in details &&
+  typeof details.specId === 'string' &&
+  'phase' in details &&
+  details.phase === WORKFLOW_PHASES.CANDIDATE_READY;
+
 export default (pi: ExtensionAPI): void => {
   registerCreateSpecTool(pi);
   registerMarkSpecReadyTool(pi);
@@ -58,14 +58,10 @@ export default (pi: ExtensionAPI): void => {
   registerRunSimplifierTool(pi);
 
   const syncMainTools = (): void => {
-    const foreignTools = pi
-      .getActiveTools()
-      .filter((name) => !MAIN_TOOL_NAMES.includes(name));
+    const foreignTools = pi.getActiveTools().filter((name) => !MAIN_TOOL_NAMES.includes(name));
 
     pi.setActiveTools(
-      maestroSessionState.isActive()
-        ? [...foreignTools, ...MAIN_TOOL_NAMES]
-        : foreignTools,
+      maestroSessionState.isActive() ? [...foreignTools, ...MAIN_TOOL_NAMES] : foreignTools,
     );
   };
 
@@ -118,10 +114,7 @@ export default (pi: ExtensionAPI): void => {
           'info',
         );
       } catch (error) {
-        context.ui.notify(
-          error instanceof Error ? error.message : String(error),
-          'error',
-        );
+        context.ui.notify(error instanceof Error ? error.message : String(error), 'error');
 
         return;
       }
@@ -146,8 +139,45 @@ export default (pi: ExtensionAPI): void => {
   // Pi fires this after a tool returns, before its result reaches the AI.
   // Refresh status after main Maestro tools, without changing the tool result.
   pi.on('tool_result', async (event, context) => {
+    if (!event.isError && isCompletedWorkflowResult(event.details)) {
+      maestroSessionState.setWaitingForFinalResponseMode(event.details.specId);
+    }
+
     if (MAIN_TOOL_NAMES.includes(event.toolName)) {
       await refreshMaestroStatus(context);
     }
   });
+
+  // Finish at the response boundary, before Pi can process a queued follow-up.
+  // Assistant messages that request tools are still preparing the final summary.
+  pi.on('message_end', async (event, context) => {
+    const message = event.message;
+
+    if (
+      !maestroSessionState.isWaitingForFinalResponse() ||
+      message.role !== 'assistant' ||
+      message.stopReason === 'toolUse'
+    ) {
+      return;
+    }
+
+    maestroSessionState.stopWaitingForFinalResponse();
+
+    if (
+      !maestroSessionState.isActive() ||
+      context.signal?.aborted ||
+      message.stopReason !== 'stop' ||
+      !message.content.some((part) => part.type === 'text' && part.text.trim() !== '')
+    ) {
+      return;
+    }
+
+    maestroSessionState.deactivate();
+    syncMainTools();
+    await refreshMaestroStatus(context);
+  });
+
+  pi.on('agent_end', () => {
+    maestroSessionState.stopWaitingForFinalResponse();
+  });
 };

package/package.json

@@ -1,30 +1,23 @@
 {
   "name": "@emiliosp/pi-maestro",
-  "version": "0.11.0",
+  "version": "0.13.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/",
@@ -35,12 +28,15 @@
     "docs/",
     "MISSION.md",
     "TECH_STACK.md",
-    "ROADMAP.md",
     "CHANGELOG.md",
     "ADR.md",
     "README.md",
     "LICENSE"
   ],
+  "os": [
+    "darwin"
+  ],
+  "type": "module",
   "imports": {
     "#config/*": "./src/config/*",
     "#specs/*": "./src/specs/*",
@@ -53,41 +49,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 +99,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,
@@ -194,19 +186,14 @@ export class MaestroPaths {
     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

@@ -4,7 +4,9 @@
  */
 
 import { isAbsolute, resolve } from 'node:path';
+
 import { Value } from 'typebox/value';
+
 import {
   type SimplifierHandoff,
   SimplifierHandoffSchema,
@@ -17,9 +19,7 @@ type AssertSimplifierHandoffInput<Handoff = unknown> = {
   projectRoot: string;
 };
 
-function assertSimplifierHandoffSchema(
-  input: unknown,
-): asserts input is SimplifierHandoff {
+function assertSimplifierHandoffSchema(input: unknown): asserts input is SimplifierHandoff {
   const [error] = Value.Errors(SimplifierHandoffSchema, input);
 
   if (error !== undefined) {

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

@@ -4,6 +4,7 @@
  */
 
 import { type Static, Type } from 'typebox';
+
 import { SPEC_ID_PATTERN } from '#ids/isValidSpecId.ts';
 
 export const SIMPLIFIER_HANDOFF_VERSION = '1.0.0';

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,
@@ -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;
 

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';
@@ -24,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.');
   }
@@ -59,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,
@@ -85,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);