@emiliosp/pi-maestro 0.11.0 → 0.13.0

package/src/tools/main/resolve-findings.ts

@@ -6,6 +6,7 @@
 import { StringEnum } from '@earendil-works/pi-ai';
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
 import { Type } from 'typebox';
+
 import { FINDING_DECISIONS } from '#artifacts/verifier-handoff/schema.ts';
 import { SPEC_ID_PATTERN } from '#ids/isValidSpecId.ts';
 import { resolveToolRunContext } from '#tools/utils/resolveToolRunContext.ts';
@@ -86,9 +87,7 @@ const formatResolution = (details: FindingResolutionDetails): string => {
   const summary = `Recorded rejections for ${rejected}. Findings requiring code fixes: ${requiringFix}.`;
 
   if (details.phase === WORKFLOW_PHASES.DRAFTING_SPEC) {
-    const requiringRevision = formatFindingIds(
-      details.findingsRequiringSpecRevisionIds,
-    );
+    const requiringRevision = formatFindingIds(details.findingsRequiringSpecRevisionIds);
 
     return `${summary} Findings requiring spec revision: ${requiringRevision}. The workflow is drafting-spec. Revise the same spec with the owner and obtain renewed GREEN FLAG. Then call maestro_mark_spec_ready separately before running the builder.`;
   }
@@ -106,13 +105,7 @@ export const registerResolveFindingsTool = (pi: ExtensionAPI): void => {
     label: RESOLVE_FINDINGS_TOOL.LABEL,
     description: RESOLVE_FINDINGS_TOOL.DESCRIPTION,
     parameters: ResolveFindingsToolParameters,
-    async execute(
-      _toolCallId,
-      { specId, decisions },
-      _signal,
-      _onUpdate,
-      context,
-    ) {
+    async execute(_toolCallId, { specId, decisions }, _signal, _onUpdate, context) {
       const { paths } = await resolveToolRunContext(context.cwd);
 
       const resolved = await resolveFindings({
@@ -126,20 +119,13 @@ export const registerResolveFindingsTool = (pi: ExtensionAPI): void => {
         phase: resolved.state.phase,
         projectRoot: resolved.projectRoot,
         rejectedFindingIds: resolved.findings
-          .filter(
-            ({ decision }) => decision?.decision === FINDING_DECISIONS.REJECT,
-          )
+          .filter(({ decision }) => decision?.decision === FINDING_DECISIONS.REJECT)
           .map(({ id }) => id),
         findingsRequiringSpecRevisionIds: resolved.findings
-          .filter(
-            ({ decision }) =>
-              decision?.decision === FINDING_DECISIONS.REVISE_SPEC,
-          )
+          .filter(({ decision }) => decision?.decision === FINDING_DECISIONS.REVISE_SPEC)
           .map(({ id }) => id),
         findingsRequiringFixIds: resolved.findings
-          .filter(
-            ({ decision }) => decision?.decision === FINDING_DECISIONS.FIX_CODE,
-          )
+          .filter(({ decision }) => decision?.decision === FINDING_DECISIONS.FIX_CODE)
           .map(({ id }) => id),
       };
 

package/src/tools/main/run-builder.ts

@@ -4,9 +4,11 @@
  */
 
 import { randomUUID } from 'node:crypto';
+
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
 import type { SubagentDelegationRequest } from 'pi-subagents/delegation';
 import { Type } from 'typebox';
+
 import { readBuilderHandoff } from '#artifacts/builder-handoff/readBuilderHandoff.ts';
 import {
   BUILDER_HANDOFF_STATUSES,
@@ -14,8 +16,8 @@ import {
 } from '#artifacts/builder-handoff/schema.ts';
 import { AGENTS } from '#config/schema.ts';
 import { SPEC_ID_PATTERN } from '#ids/isValidSpecId.ts';
-import type { MaestroPaths } from '#MaestroPaths.ts';
 import { refreshMaestroStatus } from '#maestro/status/refreshMaestroStatus.ts';
+import type { MaestroPaths } from '#MaestroPaths.ts';
 import {
   assertDelegationResponse,
   waitForDelegationResponse,
@@ -24,7 +26,7 @@ import { resolveToolRunContext } from '#tools/utils/resolveToolRunContext.ts';
 import { prepareBuilderRun } from '#workflow/builder/prepareBuilderRun.ts';
 import { WORKFLOW_ROLES } from '#workflow/roles.ts';
 import { readWorkflowState } from '#workflow/state/readWorkflowState.ts';
-import { WORKFLOW_PHASES, type WorkflowState } from '#workflow/state/schema.ts';
+import { WORKFLOW_PHASES } from '#workflow/state/schema.ts';
 
 export const RUN_BUILDER_TOOL = {
   NAME: 'maestro_run_builder',
@@ -69,76 +71,54 @@ const readBuilderResult = async ({
     const state = await readWorkflowState(paths.getWorkflowPath(specId));
 
     if (state.specId !== specId) {
-      throw new Error(
-        `Workflow spec ID mismatch: expected "${specId}", found "${state.specId}".`,
-      );
+      throw new Error(`Workflow spec ID mismatch: expected "${specId}", found "${state.specId}".`);
     }
 
-    return await readTerminalBuilderResult({ paths, specId, state });
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-
-    throw new Error(`Builder protocol error: ${message}.`, { cause: error });
-  }
-};
+    if (
+      state.phase !== WORKFLOW_PHASES.READY_FOR_VERIFIER &&
+      state.phase !== WORKFLOW_PHASES.ESCALATION_DECISIONS
+    ) {
+      throw new Error(`Builder returned with unexpected workflow phase "${state.phase}".`);
+    }
 
-type ReadTerminalBuilderResultInput = {
-  paths: MaestroPaths;
-  specId: string;
-  state: WorkflowState;
-};
+    const handoff = await readBuilderHandoff({
+      path: await paths.getActiveBuilderHandoffPath(specId),
+      specId,
+    });
 
-const readTerminalBuilderResult = async ({
-  paths,
-  specId,
-  state,
-}: ReadTerminalBuilderResultInput): Promise<BuilderRunResult> => {
-  if (
-    state.phase !== WORKFLOW_PHASES.READY_FOR_VERIFIER &&
-    state.phase !== WORKFLOW_PHASES.ESCALATION_DECISIONS
-  ) {
-    throw new Error(
-      `Builder returned with unexpected workflow phase "${state.phase}".`,
-    );
-  }
+    const expectedStatus =
+      state.phase === WORKFLOW_PHASES.READY_FOR_VERIFIER
+        ? BUILDER_HANDOFF_STATUSES.DONE
+        : BUILDER_HANDOFF_STATUSES.ESCALATION;
 
-  const handoff = await readBuilderHandoff({
-    path: await paths.getActiveBuilderHandoffPath(specId),
-    specId,
-  });
+    if (handoff.status !== expectedStatus) {
+      throw new Error(`Builder handoff status does not match workflow phase "${state.phase}".`);
+    }
 
-  const expectedStatus =
-    state.phase === WORKFLOW_PHASES.READY_FOR_VERIFIER
-      ? BUILDER_HANDOFF_STATUSES.DONE
-      : BUILDER_HANDOFF_STATUSES.ESCALATION;
+    if (state.phase === WORKFLOW_PHASES.READY_FOR_VERIFIER) {
+      return {
+        outcome: BUILDER_HANDOFF_STATUSES.DONE,
+        specId,
+        phase: state.phase,
+        handoff,
+      };
+    }
 
-  if (handoff.status !== expectedStatus) {
-    throw new Error(
-      `Builder handoff status does not match workflow phase "${state.phase}".`,
-    );
-  }
+    if (handoff.escalations.some(({ resolution }) => resolution !== null)) {
+      throw new Error('Current builder escalations already contain an owner resolution.');
+    }
 
-  if (state.phase === WORKFLOW_PHASES.READY_FOR_VERIFIER) {
     return {
-      outcome: BUILDER_HANDOFF_STATUSES.DONE,
+      outcome: BUILDER_HANDOFF_STATUSES.ESCALATION,
       specId,
       phase: state.phase,
       handoff,
     };
-  }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
 
-  if (handoff.escalations.some(({ resolution }) => resolution !== null)) {
-    throw new Error(
-      'Current builder escalations already contain an owner resolution.',
-    );
+    throw new Error(`Builder protocol error: ${message}.`, { cause: error });
   }
-
-  return {
-    outcome: BUILDER_HANDOFF_STATUSES.ESCALATION,
-    specId,
-    phase: state.phase,
-    handoff,
-  };
 };
 
 const formatBuilderResult = (result: BuilderRunResult): string => {

package/src/tools/main/run-simplifier.ts

@@ -4,14 +4,16 @@
  */
 
 import { randomUUID } from 'node:crypto';
+
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
 import type { SubagentDelegationRequest } from 'pi-subagents/delegation';
 import { Type } from 'typebox';
+
 import { readSimplifierHandoff } from '#artifacts/simplifier-handoff/readSimplifierHandoff.ts';
 import { AGENTS } from '#config/schema.ts';
 import { SPEC_ID_PATTERN } from '#ids/isValidSpecId.ts';
-import type { MaestroPaths } from '#MaestroPaths.ts';
 import { refreshMaestroStatus } from '#maestro/status/refreshMaestroStatus.ts';
+import type { MaestroPaths } from '#MaestroPaths.ts';
 import {
   assertDelegationResponse,
   waitForDelegationResponse,
@@ -44,16 +46,11 @@ type GitReadinessInput = {
   projectRoot: string;
 };
 
-const isGitReady = async ({
-  pi,
-  projectRoot,
-}: GitReadinessInput): Promise<boolean> => {
+const isGitReady = async ({ pi, projectRoot }: GitReadinessInput): Promise<boolean> => {
   try {
-    const result = await pi.exec(
-      'git',
-      ['rev-parse', '--is-inside-work-tree'],
-      { cwd: projectRoot },
-    );
+    const result = await pi.exec('git', ['rev-parse', '--is-inside-work-tree'], {
+      cwd: projectRoot,
+    });
 
     return result.code === 0 && result.stdout.trim() === 'true';
   } catch {
@@ -66,17 +63,12 @@ type ReadSimplifierResultInput = {
   specId: string;
 };
 
-const readSimplifierResult = async ({
-  paths,
-  specId,
-}: ReadSimplifierResultInput) => {
+const readSimplifierResult = async ({ paths, specId }: ReadSimplifierResultInput) => {
   try {
     const state = await readWorkflowState(paths.getWorkflowPath(specId));
 
     if (state.specId !== specId) {
-      throw new Error(
-        `Workflow spec ID mismatch: expected "${specId}", found "${state.specId}".`,
-      );
+      throw new Error(`Workflow spec ID mismatch: expected "${specId}", found "${state.specId}".`);
     }
 
     if (state.phase !== WORKFLOW_PHASES.CANDIDATE_READY) {
@@ -105,9 +97,7 @@ export const registerRunSimplifierTool = (pi: ExtensionAPI): void => {
     description: RUN_SIMPLIFIER_TOOL.DESCRIPTION,
     parameters: RunSimplifierToolParameters,
     async execute(toolCallId, { specId }, _signal, _onUpdate, context) {
-      const { paths, config, projectRoot } = await resolveToolRunContext(
-        context.cwd,
-      );
+      const { paths, config, projectRoot } = await resolveToolRunContext(context.cwd);
 
       const workflowPath = paths.getWorkflowPath(specId);
       const state = await readWorkflowState(workflowPath);

package/src/tools/main/run-verifier.ts

@@ -4,15 +4,17 @@
  */
 
 import { randomUUID } from 'node:crypto';
+
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
 import type { SubagentDelegationRequest } from 'pi-subagents/delegation';
 import { Type } from 'typebox';
+
 import { readVerifierHandoff } from '#artifacts/verifier-handoff/readVerifierHandoff.ts';
 import type { VerifierHandoff } from '#artifacts/verifier-handoff/schema.ts';
 import { AGENTS } from '#config/schema.ts';
 import { SPEC_ID_PATTERN } from '#ids/isValidSpecId.ts';
-import type { MaestroPaths } from '#MaestroPaths.ts';
 import { refreshMaestroStatus } from '#maestro/status/refreshMaestroStatus.ts';
+import type { MaestroPaths } from '#MaestroPaths.ts';
 import {
   assertDelegationResponse,
   waitForDelegationResponse,
@@ -20,7 +22,7 @@ import {
 import { resolveToolRunContext } from '#tools/utils/resolveToolRunContext.ts';
 import { WORKFLOW_ROLES } from '#workflow/roles.ts';
 import { readWorkflowState } from '#workflow/state/readWorkflowState.ts';
-import { WORKFLOW_PHASES, type WorkflowState } from '#workflow/state/schema.ts';
+import { WORKFLOW_PHASES } from '#workflow/state/schema.ts';
 import { prepareVerifierRun } from '#workflow/verifier/prepareVerifierRun.ts';
 
 export const RUN_VERIFIER_TOOL = {
@@ -50,50 +52,6 @@ type VerifierRunResult = {
   handoff: VerifierHandoff;
 };
 
-type ReadTerminalVerifierResultInput = {
-  paths: MaestroPaths;
-  specId: string;
-  state: WorkflowState;
-};
-
-const readTerminalVerifierResult = async ({
-  paths,
-  specId,
-  state,
-}: ReadTerminalVerifierResultInput): Promise<VerifierRunResult> => {
-  if (
-    state.phase !== WORKFLOW_PHASES.SIMPLIFIER_RUNNING &&
-    state.phase !== WORKFLOW_PHASES.FINDING_DECISIONS
-  ) {
-    throw new Error(
-      `Verifier returned with unexpected workflow phase "${state.phase}".`,
-    );
-  }
-
-  const handoff = await readVerifierHandoff({
-    path: await paths.getActiveVerifierHandoffPath(specId),
-    specId,
-  });
-
-  const expectedPhase =
-    handoff.findings.length > 0
-      ? WORKFLOW_PHASES.FINDING_DECISIONS
-      : WORKFLOW_PHASES.SIMPLIFIER_RUNNING;
-
-  if (state.phase !== expectedPhase) {
-    throw new Error(
-      `Verifier handoff findings do not match workflow phase "${state.phase}".`,
-    );
-  }
-
-  return {
-    specId,
-    handoff,
-    outcome: state.phase,
-    phase: state.phase,
-  };
-};
-
 type ReadVerifierResultInput = {
   paths: MaestroPaths;
   specId: string;
@@ -107,22 +65,40 @@ const readVerifierResult = async ({
     const state = await readWorkflowState(paths.getWorkflowPath(specId));
 
     if (state.specId !== specId) {
-      throw new Error(
-        `Workflow spec ID mismatch: expected "${specId}", found "${state.specId}".`,
-      );
+      throw new Error(`Workflow spec ID mismatch: expected "${specId}", found "${state.specId}".`);
     }
 
     if (state.phase === WORKFLOW_PHASES.VERIFIER_RUNNING) {
-      throw new Error(
-        'The verifier returned without recording a valid terminal handoff.',
-      );
+      throw new Error('The verifier returned without recording a valid terminal handoff.');
     }
 
-    return await readTerminalVerifierResult({
-      paths,
+    if (
+      state.phase !== WORKFLOW_PHASES.SIMPLIFIER_RUNNING &&
+      state.phase !== WORKFLOW_PHASES.FINDING_DECISIONS
+    ) {
+      throw new Error(`Verifier returned with unexpected workflow phase "${state.phase}".`);
+    }
+
+    const handoff = await readVerifierHandoff({
+      path: await paths.getActiveVerifierHandoffPath(specId),
       specId,
-      state,
     });
+
+    const expectedPhase =
+      handoff.findings.length > 0
+        ? WORKFLOW_PHASES.FINDING_DECISIONS
+        : WORKFLOW_PHASES.SIMPLIFIER_RUNNING;
+
+    if (state.phase !== expectedPhase) {
+      throw new Error(`Verifier handoff findings do not match workflow phase "${state.phase}".`);
+    }
+
+    return {
+      specId,
+      handoff,
+      outcome: state.phase,
+      phase: state.phase,
+    };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
 

package/src/tools/utils/pi-subagent-delegation.ts

@@ -50,8 +50,7 @@ export const matchesDelegationRequest = ({
 
   return (
     response.requestId === request.requestId &&
-    (response.ownerRunId === undefined ||
-      response.ownerRunId === request.ownerRunId) &&
+    (response.ownerRunId === undefined || response.ownerRunId === request.ownerRunId) &&
     (response.nodeId === undefined || response.nodeId === request.nodeId)
   );
 };
@@ -65,20 +64,16 @@ export const waitForDelegationResponse = async ({
   piEventsBus,
   request,
 }: WaitForDelegationResponseInput): Promise<SubagentDelegationResponse> => {
-  const { promise, resolve } =
-    Promise.withResolvers<SubagentDelegationResponse>();
-
-  const unsubscribe = piEventsBus.on(
-    SUBAGENT_DELEGATION_RESPONSE_EVENT,
-    (payload) => {
-      if (!matchesDelegationRequest({ request, payload })) {
-        return;
-      }
-
-      // JUSTIFICATION: matchesDelegationRequest accepts only the response for this pi-subagents request.
-      resolve(payload as SubagentDelegationResponse);
-    },
-  );
+  const { promise, resolve } = Promise.withResolvers<SubagentDelegationResponse>();
+
+  const unsubscribe = piEventsBus.on(SUBAGENT_DELEGATION_RESPONSE_EVENT, (payload) => {
+    if (!matchesDelegationRequest({ request, payload })) {
+      return;
+    }
+
+    // JUSTIFICATION: matchesDelegationRequest accepts only the response for this pi-subagents request.
+    resolve(payload as SubagentDelegationResponse);
+  });
 
   try {
     try {
@@ -97,9 +92,7 @@ export const waitForDelegationResponse = async ({
   }
 };
 
-export function assertDelegationResponse(
-  response: SubagentDelegationResponse,
-): void {
+export function assertDelegationResponse(response: SubagentDelegationResponse): void {
   if (response.status === DELEGATION_STATUSES.COMPLETED) {
     return;
   }
@@ -121,7 +114,5 @@ export function assertDelegationResponse(
     throw new Error(`Delegation error: ${error}`);
   }
 
-  throw new Error(
-    `Protocol error: unsupported final response status "${response.status}".`,
-  );
+  throw new Error(`Protocol error: unsupported final response status "${response.status}".`);
 }

package/src/tools/utils/resolveToolRunContext.ts

@@ -4,6 +4,7 @@
  */
 
 import { realpath } from 'node:fs/promises';
+
 import { loadConfiguration } from '#config/loadConfiguration.ts';
 import type { MaestroConfig } from '#config/schema.ts';
 import { MaestroPaths } from '#MaestroPaths.ts';
@@ -14,9 +15,7 @@ export type ToolRunContext = {
   paths: MaestroPaths;
 };
 
-export const resolveToolRunContext = async (
-  cwd: string,
-): Promise<ToolRunContext> => {
+export const resolveToolRunContext = async (cwd: string): Promise<ToolRunContext> => {
   const projectRoot = await realpath(cwd);
   const config = await loadConfiguration(projectRoot);
 

package/src/utils/is-errno-exception.ts

@@ -3,7 +3,5 @@
  * Used: When filesystem operations handle specific error codes.
  */
 
-export const isErrnoException = (
-  error: unknown,
-): error is NodeJS.ErrnoException =>
+export const isErrnoException = (error: unknown): error is NodeJS.ErrnoException =>
   error instanceof Error && 'code' in error && typeof error.code === 'string';

package/src/utils/path-exists.ts

@@ -4,6 +4,7 @@
  */
 
 import { access } from 'node:fs/promises';
+
 import { isErrnoException } from '#utils/is-errno-exception.ts';
 
 export const pathExists = async (path: string): Promise<boolean> => {

package/src/utils/path-strictly-within.ts

@@ -4,6 +4,7 @@
  */
 
 import { relative } from 'node:path';
+
 import { isPathWithinOrEqual } from '#utils/path-within-or-equal.ts';
 
 type IsPathStrictlyWithinInput = {
@@ -11,9 +12,5 @@ type IsPathStrictlyWithinInput = {
   path: string;
 };
 
-export const isPathStrictlyWithin = ({
-  parent,
-  path,
-}: IsPathStrictlyWithinInput): boolean =>
-  relative(parent, path) !== '' &&
-  isPathWithinOrEqual({ parent, candidate: path });
+export const isPathStrictlyWithin = ({ parent, path }: IsPathStrictlyWithinInput): boolean =>
+  relative(parent, path) !== '' && isPathWithinOrEqual({ parent, candidate: path });

package/src/utils/path-within-or-equal.ts

@@ -10,10 +10,7 @@ type IsPathWithinOrEqualInput = {
   candidate: string;
 };
 
-export const isPathWithinOrEqual = ({
-  parent,
-  candidate,
-}: IsPathWithinOrEqualInput): boolean => {
+export const isPathWithinOrEqual = ({ parent, candidate }: IsPathWithinOrEqualInput): boolean => {
   const pathToCandidate = relative(parent, candidate);
 
   return (

package/src/utils/read-json.ts

@@ -10,10 +10,7 @@ type ReadJsonFileInput = {
   description: string;
 };
 
-export const readJsonFile = async ({
-  path,
-  description,
-}: ReadJsonFileInput): Promise<unknown> => {
+export const readJsonFile = async ({ path, description }: ReadJsonFileInput): Promise<unknown> => {
   const content = await readFile(path, 'utf8');
 
   try {

package/src/utils/write-json.ts

@@ -10,10 +10,7 @@ type WriteJsonInput = {
   data: unknown;
 };
 
-export const writeJson = async ({
-  path,
-  data,
-}: WriteJsonInput): Promise<void> => {
+export const writeJson = async ({ path, data }: WriteJsonInput): Promise<void> => {
   const content = JSON.stringify(data, null, 2);
 
   if (content === undefined) {

package/src/workflow/builder/completeBuilderPass.ts

@@ -4,7 +4,9 @@
  */
 
 import { mkdir, readFile } from 'node:fs/promises';
+
 import { Value } from 'typebox/value';
+
 import { assertBuilderHandoff } from '#artifacts/builder-handoff/assertBuilderHandoff.ts';
 import {
   BUILDER_HANDOFF_VERSION,
@@ -33,8 +35,7 @@ function assertBuilderHandoffSubmission(
 ): asserts input is BuilderHandoffSubmissionInput {
   const [error] = Value.Errors(BuilderHandoffSubmissionSchema, input);
 
-  if (error !== undefined)
-    throw new Error(`Invalid builder submission: ${error.message}.`);
+  if (error !== undefined) throw new Error(`Invalid builder submission: ${error.message}.`);
 }
 
 type CompleteBuilderPassInput = {

package/src/workflow/builder/prepareBuilderRun.ts

@@ -3,8 +3,8 @@
  * Used: Before Maestro runs a builder pass.
  */
 
-import type { MaestroPaths } from '#MaestroPaths.ts';
 import maestroSessionState from '#maestro/session/MaestroSessionState.ts';
+import type { MaestroPaths } from '#MaestroPaths.ts';
 import { pathExists } from '#utils/path-exists.ts';
 import { readWorkflowState } from '#workflow/state/readWorkflowState.ts';
 import { WORKFLOW_EVENTS, WORKFLOW_PHASES } from '#workflow/state/schema.ts';
@@ -21,16 +21,11 @@ type AssertBuilderRunBaseInput = {
   specId: string;
 };
 
-async function assertBuilderRunBase({
-  paths,
-  specId,
-}: AssertBuilderRunBaseInput): Promise<void> {
+async function assertBuilderRunBase({ paths, specId }: AssertBuilderRunBaseInput): Promise<void> {
   const state = await readWorkflowState(paths.getWorkflowPath(specId));
 
   if (state.specId !== specId) {
-    throw new Error(
-      `Workflow spec ID mismatch: expected "${specId}", found "${state.specId}".`,
-    );
+    throw new Error(`Workflow spec ID mismatch: expected "${specId}", found "${state.specId}".`);
   }
 
   if (state.phase !== WORKFLOW_PHASES.READY_FOR_BUILDER) {

package/src/workflow/builder/resolveEscalations.ts

@@ -26,16 +26,12 @@ type ApplyEscalationDecisionsInput = {
   decisions: EscalationDecision[];
 };
 
-const applyEscalationDecisions = ({
-  escalations,
-  decisions,
-}: ApplyEscalationDecisionsInput) => {
+const applyEscalationDecisions = ({ escalations, decisions }: ApplyEscalationDecisionsInput) => {
   if (escalations.some(({ resolution }) => resolution !== null)) {
     throw new Error('Current questions already contain an owner resolution.');
   }
 
-  if (decisions.length === 0)
-    throw new Error('At least one escalation decision is required.');
+  if (decisions.length === 0) throw new Error('At least one escalation decision is required.');
 
   const expectedIds = new Set(escalations.map(({ id }) => id));
   const resolutions = new Map<string, EscalationResolution>();

package/src/workflow/builder/utils/getWorkflowEventByBuilderHandoff.ts

@@ -9,9 +9,7 @@ import {
 } from '#artifacts/builder-handoff/schema.ts';
 import { WORKFLOW_EVENTS, type WorkflowEvent } from '#workflow/state/schema.ts';
 
-export const getWorkflowEventByBuilderHandoff = ({
-  status,
-}: BuilderHandoff): WorkflowEvent => {
+export const getWorkflowEventByBuilderHandoff = ({ status }: BuilderHandoff): WorkflowEvent => {
   if (status === BUILDER_HANDOFF_STATUSES.DONE) {
     return WORKFLOW_EVENTS.BUILDER_DONE;
   }

package/src/workflow/simplifier/completeSimplifierPass.ts

@@ -5,6 +5,7 @@
 
 import { mkdir } from 'node:fs/promises';
 import { dirname } from 'node:path';
+
 import { assertSimplifierHandoff } from '#artifacts/simplifier-handoff/assertSimplifierHandoff.ts';
 import type { MaestroPaths } from '#MaestroPaths.ts';
 import { writeJson } from '#utils/write-json.ts';
@@ -28,9 +29,7 @@ export const completeSimplifierPass = async ({
   const state = await readWorkflowState(workflowPath);
 
   if (state.specId !== specId) {
-    throw new Error(
-      `Workflow spec ID mismatch: expected "${specId}", found "${state.specId}".`,
-    );
+    throw new Error(`Workflow spec ID mismatch: expected "${specId}", found "${state.specId}".`);
   }
 
   if (state.phase !== WORKFLOW_PHASES.SIMPLIFIER_RUNNING) {