@emiliosp/pi-maestro 0.6.3 → 0.7.1

package/src/MaestroPaths.ts

@@ -15,7 +15,6 @@ const PATHS = {
   HANDOFFS_PATH: 'handoffs',
   BUILDER_HANDOFFS_PATH: 'handoffs/builder',
   VERIFIER_HANDOFFS_PATH: 'handoffs/verifier',
-  ESCALATIONS_PATH: 'handoffs/escalations',
   PROTOTYPES_PATH: 'prototypes',
 } as const;
 
@@ -55,11 +54,6 @@ export type MaestroPathsInput = {
   config: MaestroConfig;
 };
 
-type EscalationPathInput = {
-  specId: string;
-  escalationNumber: number;
-};
-
 type HandoffPathInput = {
   specId: string;
   handoffPassNumber: number;
@@ -213,32 +207,6 @@ export class MaestroPaths {
     });
   }
 
-  public getEscalationsPath(specId: string): string {
-    assertSpecId(specId);
-
-    return resolve(
-      this.projectRoot,
-      this.specDirectoryFromRoot,
-      specId,
-      PATHS.ESCALATIONS_PATH,
-    );
-  }
-
-  public getEscalationPath({
-    specId,
-    escalationNumber,
-  }: EscalationPathInput): string {
-    assertArtifactNumber(escalationNumber);
-    assertSpecId(specId);
-
-    return resolve(
-      this.projectRoot,
-      this.specDirectoryFromRoot,
-      specId,
-      `${PATHS.ESCALATIONS_PATH}/E${escalationNumber}.json`,
-    );
-  }
-
   public getPrototypesPath(specId: string): string {
     assertSpecId(specId);
 

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

@@ -80,6 +80,35 @@ export function assertBuilderHandoff(
     );
   }
 
+  if (handoff.status === BUILDER_HANDOFF_STATUSES.ESCALATION) {
+    for (const [index, escalation] of handoff.escalations.entries()) {
+      if (escalation.id !== `E${index + 1}`) {
+        throw new Error('Escalation IDs must be sequential in array order.');
+      }
+
+      const optionIds = new Set(escalation.options.map(({ id }) => id));
+
+      if (optionIds.size !== escalation.options.length) {
+        throw new Error('Escalation option IDs must be unique.');
+      }
+
+      if (
+        escalation.recommendation !== null &&
+        !optionIds.has(escalation.recommendation.optionId)
+      ) {
+        throw new Error('Escalation recommendation references unknown option.');
+      }
+
+      if (
+        escalation.resolution !== null &&
+        escalation.resolution.selectedOptionId !== null &&
+        !optionIds.has(escalation.resolution.selectedOptionId)
+      ) {
+        throw new Error('Escalation resolution references unknown option.');
+      }
+    }
+  }
+
   if (!isValidSpecId(specId)) {
     throw new Error(`Invalid expected builder handoff spec ID: "${specId}".`);
   }

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

@@ -37,6 +37,10 @@ export const BuilderAcceptanceCriterionSchema = Type.Object(
   { additionalProperties: false },
 );
 
+export type BuilderAcceptanceCriterion = Static<
+  typeof BuilderAcceptanceCriterionSchema
+>;
+
 export const BuilderHandoffFailureSchema = Type.Object(
   { reason: Type.String({ minLength: 1 }) },
   { additionalProperties: false },
@@ -55,10 +59,77 @@ const BuilderHandoffFields = {
   ...BuilderHandoffContentFields,
 };
 
+export const ESCALATION_ID_PATTERN = /^E([1-9]\d*)$/;
+
+export const EscalationOptionSchema = Type.Object(
+  {
+    id: Type.String({ minLength: 1 }),
+    description: Type.String({ minLength: 1 }),
+    consequences: Type.String({ minLength: 1 }),
+    nextStep: Type.String({ minLength: 1 }),
+  },
+  { additionalProperties: false },
+);
+
+export const EscalationRecommendationSchema = Type.Object(
+  {
+    optionId: Type.String({ minLength: 1 }),
+    reason: Type.String({ minLength: 1 }),
+  },
+  { additionalProperties: false },
+);
+
+export const EscalationResolutionSchema = Type.Object(
+  {
+    selectedOptionId: Type.Union([Type.String({ minLength: 1 }), Type.Null()]),
+    decision: Type.String({ minLength: 1, pattern: '\\S' }),
+    reason: Type.String({ minLength: 1, pattern: '\\S' }),
+  },
+  { additionalProperties: false },
+);
+
+const EscalationContentFields = {
+  question: Type.String({ minLength: 1 }),
+  context: Type.String({ minLength: 1 }),
+  options: Type.Array(EscalationOptionSchema, { minItems: 1 }),
+  notes: Type.Array(Type.String()),
+};
+
+export const EscalationSchema = Type.Object(
+  {
+    id: Type.String({ pattern: ESCALATION_ID_PATTERN.source }),
+    ...EscalationContentFields,
+    recommendation: Type.Union([EscalationRecommendationSchema, Type.Null()]),
+    resolution: Type.Union([EscalationResolutionSchema, Type.Null()]),
+  },
+  { additionalProperties: false },
+);
+
+const EscalationSubmissionSchema = Type.Object(
+  { ...EscalationSchema.properties, resolution: Type.Null() },
+  { additionalProperties: false },
+);
+
+export type EscalationOption = Static<typeof EscalationOptionSchema>;
+
+export type EscalationResolution = Static<typeof EscalationResolutionSchema>;
+
+export type Escalation = Static<typeof EscalationSchema>;
+
 export const BuilderDoneHandoffSchema = Type.Object(
   {
     ...BuilderHandoffFields,
     status: Type.Literal(BUILDER_HANDOFF_STATUSES.DONE),
+    escalations: Type.Array(EscalationSchema, { maxItems: 0 }),
+  },
+  { additionalProperties: false },
+);
+
+export const BuilderEscalationHandoffSchema = Type.Object(
+  {
+    ...BuilderHandoffFields,
+    status: Type.Literal(BUILDER_HANDOFF_STATUSES.ESCALATION),
+    escalations: Type.Array(EscalationSchema, { minItems: 1 }),
   },
   { additionalProperties: false },
 );
@@ -74,18 +145,31 @@ export const BuilderFailedHandoffSchema = Type.Object(
 
 export const BuilderHandoffSchema = Type.Union([
   BuilderDoneHandoffSchema,
+  BuilderEscalationHandoffSchema,
   BuilderFailedHandoffSchema,
 ]);
 
-const BuilderDoneHandoffSubmissionSchema = Type.Object(
+export type BuilderHandoff = Static<typeof BuilderHandoffSchema>;
+
+export const BuilderDoneHandoffSubmissionSchema = Type.Object(
   {
     status: Type.Literal(BUILDER_HANDOFF_STATUSES.DONE),
     ...BuilderHandoffContentFields,
+    escalations: Type.Array(EscalationSchema, { maxItems: 0 }),
+  },
+  { additionalProperties: false },
+);
+
+export const BuilderEscalationHandoffSubmissionSchema = Type.Object(
+  {
+    status: Type.Literal(BUILDER_HANDOFF_STATUSES.ESCALATION),
+    ...BuilderHandoffContentFields,
+    escalations: Type.Array(EscalationSubmissionSchema, { minItems: 1 }),
   },
   { additionalProperties: false },
 );
 
-const BuilderFailedHandoffSubmissionSchema = Type.Object(
+export const BuilderFailedHandoffSubmissionSchema = Type.Object(
   {
     status: Type.Literal(BUILDER_HANDOFF_STATUSES.FAILED),
     ...BuilderHandoffContentFields,
@@ -96,30 +180,10 @@ const BuilderFailedHandoffSubmissionSchema = Type.Object(
 
 export const BuilderHandoffSubmissionSchema = Type.Union([
   BuilderDoneHandoffSubmissionSchema,
+  BuilderEscalationHandoffSubmissionSchema,
   BuilderFailedHandoffSubmissionSchema,
 ]);
 
-export type BuilderAcceptanceCriterion = Static<
-  typeof BuilderAcceptanceCriterionSchema
->;
-
-export type BuilderHandoff = Static<typeof BuilderHandoffSchema>;
-
 export type BuilderHandoffSubmissionInput = Static<
   typeof BuilderHandoffSubmissionSchema
 >;
-
-export type BuilderHandoffSubmission =
-  | {
-      status: typeof BUILDER_HANDOFF_STATUSES.DONE;
-      summary: string;
-      acceptanceCriteria: BuilderAcceptanceCriterion[];
-      notes: string[];
-    }
-  | {
-      status: typeof BUILDER_HANDOFF_STATUSES.FAILED;
-      summary: string;
-      acceptanceCriteria: BuilderAcceptanceCriterion[];
-      failure: { reason: string };
-      notes: string[];
-    };

package/src/maestro/instructions/getMaestroInstructions.ts

@@ -16,7 +16,7 @@ The project root is the canonical Pi working directory, resolved with realpath.
 Load .pi/maestro.json only from this root. Resolve spec and product paths against this root. Children run in this directory.
 Do not add worktree checks, activation gates, warnings, or configuration changes: compatible pi-subagents configuration is the owner's responsibility.
 Use generic tools for project inspection. Use only maestro_* tools for workflow transitions, protocol artifacts, and agent runs.
-Do not edit workflow.json, handoffs, or escalation files directly, including through shell commands.
+Do not edit workflow.json or handoffs directly, including through shell commands.
 The spec, prototype, and experiment permissions below are the only exceptions for file changes.
 
 Use the specId and paths returned by maestro_create_spec. Read workflow.json before selecting the next action. Its validated phase is the source of truth.
@@ -82,7 +82,7 @@ The tool saves builder-running before launch. The builder records its result bef
 Read the returned artifact and follow its outcome:
 
 1. done: The phase is ready-for-verifier. Call maestro_run_verifier with the active specId.
-2. escalation: The phase is escalation-decision. Present the question, evidence, options, consequences, and next steps to the owner.
+2. escalation: The phase is escalation-decision. Present all questions from the active builder handoff, with evidence, options, consequences, and next steps.
 3. failed: The phase is builder-failed. Report the failure and stop. There is no builder retry or spec revision from this phase.
 
 A significant discovery needs an escalation when the owner must choose between meaningful alternatives, even without a technical blocker.
@@ -98,14 +98,14 @@ Read the returned verifier handoff. If there are findings, follow findings-decis
 
 ### Explain findings and escalations
 
-Before requesting a decision, read the active spec, the finding or escalation artifact, and the relevant code.
+Before requesting a decision, read the active spec, the handoff that contains the finding or escalation, and the relevant code.
 Trace the affected behavior across components. Do not just repeat the builder's or verifier's summary.
 For findings, inspect the live project files checked by the verifier.
 This inspection does not authorize product repairs, new verification runs, or experiments. Follow the existing permissions above.
 
 For each finding or escalation, give the owner enough detail to decide without opening other files:
 
-1. Identify findings with both handoff and finding IDs, such as V1/F1. Finding IDs are local to each verifier handoff. Identify escalations by their IDs. Explain the issue or open question and its relation to the approved contract.
+1. Identify findings with both handoff and finding IDs, such as V1/F1. Finding IDs are local to each verifier handoff. Identify escalation questions with both handoff and local IDs, such as B1/E1 or B2/E1. Escalation IDs restart at E1 in each builder handoff. Explain the issue or open question and its relation to the approved contract.
 2. For code-related issues, show a short code excerpt with its file path and line numbers. Explain how that code causes or constrains the behavior. A file reference alone is not enough.
 3. Give a concrete example with starting conditions, input or action, current behavior, and practical impact. Compare with the contract's expected result when defined. Otherwise identify the behavior that needs an owner decision.
 4. Explain each available choice, its required changes, scope, consequences, and next workflow step. For findings, cover fix-code, rejection, and spec revision when relevant. Explain what remains unchanged or unresolved if no code changes.
@@ -117,9 +117,9 @@ Keep excerpts and explanations focused, but do not replace the details with seve
 
 ### Record owner decisions
 
-In escalation-decision, wait for the explicit owner answer. Do not choose an option for the owner.
-If the contract stays unchanged, call maestro_resolve_escalation with the current escalation ID and the owner's decision and reason.
-The tool saves the resolution and returns ready-for-builder. Call maestro_run_builder separately.
+In escalation-decision, collect an explicit owner answer for every current question. Do not choose options for the owner.
+If the contract stays unchanged, call maestro_resolve_escalations once with specId and the complete decisions array. Each item contains escalationId, selectedOptionId, decision, and reason. Use selectedOptionId: null for an owner decision outside the listed options. The tool saves all resolutions inside the active builder handoff. Do not submit partial batches.
+The tool saves all resolutions and returns ready-for-builder. Call maestro_run_builder separately.
 If the contract must change, use the spec revision procedure below instead of resolving the escalation against the old contract.
 
 In findings-decision, present every current finding. Every finding requires an owner decision, regardless of severity.

package/src/specs/create.ts

@@ -22,7 +22,6 @@ export type CreatedSpec = {
   specPath: string;
   specFilePath: string;
   workflowPath: string;
-  escalationsPath: string;
   prototypesPath: string;
   state: WorkflowState;
 };
@@ -48,7 +47,6 @@ export const createSpec = async ({
   const specPath = paths.getSpecPath(specId);
   const specFilePath = paths.getSpecFilePath(specId);
   const workflowPath = paths.getWorkflowPath(specId);
-  const escalationsPath = paths.getEscalationsPath(specId);
   const prototypesPath = paths.getPrototypesPath(specId);
 
   if (await pathExists(specPath)) {
@@ -71,7 +69,6 @@ export const createSpec = async ({
     await mkdir(paths.getSpecDirectory(), { recursive: true });
     await mkdir(specPath);
     created = true;
-    await mkdir(escalationsPath, { recursive: true });
     await mkdir(prototypesPath, { recursive: true });
     await writeFile(specFilePath, spec, { encoding: 'utf8', flag: 'wx' });
     await writeWorkflowState({
@@ -100,7 +97,6 @@ export const createSpec = async ({
     specPath,
     specFilePath,
     workflowPath,
-    escalationsPath,
     prototypesPath,
     state,
   };

package/src/tools/child/record-builder-handoff.ts

@@ -1,14 +1,14 @@
 /**
  * Objective: Register the builder handoff tool for the current project.
- * Used: When the builder reports a done or failed result.
+ * Used: When the builder reports a done, escalation, or failed result.
  */
 
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
 import { Type } from 'typebox';
 import {
-  BUILDER_HANDOFF_STATUSES,
-  BuilderAcceptanceCriterionSchema,
-  BuilderHandoffFailureSchema,
+  BuilderDoneHandoffSubmissionSchema,
+  BuilderEscalationHandoffSubmissionSchema,
+  BuilderFailedHandoffSubmissionSchema,
 } from '#artifacts/builder-handoff/schema.ts';
 import { SPEC_ID_PATTERN } from '#ids/isValidSpecId.ts';
 import { resolveWorkflowContext } from '#tools/child/utils/resolveWorkflowContext.ts';
@@ -18,30 +18,28 @@ export const BUILDER_HANDOFF_TOOL = {
   NAME: 'maestro_record_builder_handoff',
   LABEL: 'Record Builder Handoff',
   DESCRIPTION:
-    'Record the builder pass as done or failed. Put significant discoveries that do not require an owner decision in notes. After success, stop. The tool saves a numbered builder handoff and the workflow phase.',
+    'Record the builder pass as done, escalation, or failed. Put significant discoveries that do not require an owner decision in notes. After success, stop. The tool saves a numbered builder handoff and the workflow phase.',
 } as const;
 
-const BuilderHandoffContentFields = {
-  summary: Type.String({ minLength: 1 }),
-  acceptanceCriteria: Type.Array(BuilderAcceptanceCriterionSchema),
-  notes: Type.Array(Type.String()),
-};
-
 const BuilderHandoffToolParameters = Type.Union([
   Type.Object(
     {
       specId: Type.String({ pattern: SPEC_ID_PATTERN.source }),
-      status: Type.Literal(BUILDER_HANDOFF_STATUSES.DONE),
-      ...BuilderHandoffContentFields,
+      ...BuilderDoneHandoffSubmissionSchema.properties,
+    },
+    { additionalProperties: false },
+  ),
+  Type.Object(
+    {
+      specId: Type.String({ pattern: SPEC_ID_PATTERN.source }),
+      ...BuilderEscalationHandoffSubmissionSchema.properties,
     },
     { additionalProperties: false },
   ),
   Type.Object(
     {
       specId: Type.String({ pattern: SPEC_ID_PATTERN.source }),
-      status: Type.Literal(BUILDER_HANDOFF_STATUSES.FAILED),
-      ...BuilderHandoffContentFields,
-      failure: BuilderHandoffFailureSchema,
+      ...BuilderFailedHandoffSubmissionSchema.properties,
     },
     { additionalProperties: false },
   ),

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

@@ -0,0 +1,72 @@
+/**
+ * Objective: Register owner resolution of every current builder escalation.
+ * Used: When the owner keeps the approved contract and resolves all current questions.
+ */
+
+import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
+import { Type } from 'typebox';
+import {
+  ESCALATION_ID_PATTERN,
+  EscalationResolutionSchema,
+} from '#artifacts/builder-handoff/schema.ts';
+import { SPEC_ID_PATTERN } from '#ids/isValidSpecId.ts';
+import { resolveToolRunContext } from '#tools/utils/resolveToolRunContext.ts';
+import { resolveEscalations } from '#workflow/escalation/resolveEscalations.ts';
+
+export const RESOLVE_ESCALATIONS_TOOL = {
+  NAME: 'maestro_resolve_escalations',
+  LABEL: 'Resolve Escalations',
+  DESCRIPTION:
+    'Record the explicit owner decision for every current builder escalation when the approved contract remains valid. Save the resolution and workflow transition, then return ready-for-builder without running the builder. If the contract must change, edit spec.md and use maestro_mark_spec_ready instead.',
+} as const;
+
+const ResolveEscalationsToolParameters = Type.Object(
+  {
+    specId: Type.String({ pattern: SPEC_ID_PATTERN.source }),
+    decisions: Type.Array(
+      Type.Object(
+        {
+          escalationId: Type.String({ pattern: ESCALATION_ID_PATTERN.source }),
+          ...EscalationResolutionSchema.properties,
+        },
+        { additionalProperties: false },
+      ),
+      { minItems: 1 },
+    ),
+  },
+  { additionalProperties: false },
+);
+
+export const registerResolveEscalationsTool = (pi: ExtensionAPI): void => {
+  pi.registerTool({
+    name: RESOLVE_ESCALATIONS_TOOL.NAME,
+    label: RESOLVE_ESCALATIONS_TOOL.LABEL,
+    description: RESOLVE_ESCALATIONS_TOOL.DESCRIPTION,
+    parameters: ResolveEscalationsToolParameters,
+    async execute(_toolCallId, params, _signal, _onUpdate, context) {
+      const { specId, decisions } = params;
+      const { paths } = await resolveToolRunContext(context.cwd);
+
+      const resolved = await resolveEscalations({
+        paths,
+        specId,
+        decisions,
+      });
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `All current escalations resolved. Spec ${resolved.state.specId} is ready-for-builder. Run the builder separately.`,
+          },
+        ],
+        details: {
+          specId: resolved.state.specId,
+          handoff: resolved.handoff,
+          phase: resolved.state.phase,
+          projectRoot: resolved.projectRoot,
+        },
+      };
+    },
+  });
+};

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

@@ -12,8 +12,6 @@ import {
   BUILDER_HANDOFF_STATUSES,
   type BuilderHandoff,
 } from '#artifacts/builder-handoff/schema.ts';
-import { readEscalationHistory } from '#artifacts/escalation/readEscalationHistory.ts';
-import type { Escalation } from '#artifacts/escalation/schema.ts';
 import { AGENTS } from '#config/schema.ts';
 import { SPEC_ID_PATTERN } from '#ids/isValidSpecId.ts';
 import type { MaestroPaths } from '#MaestroPaths.ts';
@@ -61,7 +59,7 @@ type BuilderRunResult =
       outcome: typeof BUILDER_HANDOFF_STATUSES.ESCALATION;
       specId: string;
       phase: typeof WORKFLOW_PHASES.ESCALATION_DECISION;
-      escalation: Escalation;
+      handoff: BuilderHandoff;
     };
 
 type ReadBuilderResultInput = {
@@ -159,22 +157,28 @@ const buildRunResult = async ({
   }
 
   if (state.phase === WORKFLOW_PHASES.ESCALATION_DECISION) {
-    const history = await readEscalationHistory({
-      directory: paths.getEscalationsPath(specId),
+    const handoff = await readBuilderHandoff({
+      path: await paths.getActiveBuilderHandoffPath(specId),
       specId,
     });
 
-    const escalation = history.at(-1);
+    if (handoff.status !== BUILDER_HANDOFF_STATUSES.ESCALATION) {
+      throw new Error(
+        `Builder handoff status does not match workflow phase "${state.phase}".`,
+      );
+    }
 
-    if (escalation === undefined || escalation.resolution !== null) {
-      throw new Error('The builder escalation is missing or already resolved.');
+    if (handoff.escalations.some(({ resolution }) => resolution !== null)) {
+      throw new Error(
+        'Current builder escalations already contain an owner resolution.',
+      );
     }
 
     return {
       outcome: BUILDER_HANDOFF_STATUSES.ESCALATION,
       specId,
       phase: state.phase,
-      escalation,
+      handoff,
     };
   }
 
@@ -192,7 +196,7 @@ const formatBuilderResult = (result: BuilderRunResult): string => {
     return `Builder failed for spec ${result.specId}. The workflow is builder-failed and cannot be retried.`;
   }
 
-  return `Builder opened escalation ${result.escalation.id} for spec ${result.specId}. The workflow is waiting for an owner decision.`;
+  return `Builder submitted escalation questions for spec ${result.specId}. The workflow is waiting for an owner decision.`;
 };
 
 export const registerRunBuilderTool = (pi: ExtensionAPI): void => {

package/src/workflow/builder/completeBuilderPass.ts

@@ -1,15 +1,17 @@
 /**
  * Objective: Complete a builder pass with a validated terminal handoff.
- * Used: When the builder reports done or failed through the child tool.
+ * Used: When the builder reports done, escalation, or failed through the child tool.
  */
 
 import { mkdir } from 'node:fs/promises';
+import { Value } from 'typebox/value';
 import { assertBuilderHandoff } from '#artifacts/builder-handoff/assertBuilderHandoff.ts';
 import {
   BUILDER_HANDOFF_STATUSES,
   BUILDER_HANDOFF_VERSION,
   type BuilderHandoff,
   type BuilderHandoffSubmissionInput,
+  BuilderHandoffSubmissionSchema,
 } from '#artifacts/builder-handoff/schema.ts';
 import { writeBuilderHandoff } from '#artifacts/builder-handoff/writeBuilderHandoff.ts';
 import type { MaestroPaths } from '#MaestroPaths.ts';
@@ -29,36 +31,14 @@ export type CompletedBuilderPass = {
   handoffPath: string;
 };
 
-type BuildBuilderHandoffInput = {
-  draftHandoff: BuilderHandoffSubmissionInput;
-  state: WorkflowState;
-};
-
-const buildBuilderHandoff = ({
-  draftHandoff,
-  state,
-}: BuildBuilderHandoffInput) => {
-  if (draftHandoff.status === BUILDER_HANDOFF_STATUSES.FAILED) {
-    return {
-      version: BUILDER_HANDOFF_VERSION,
-      specId: state.specId,
-      status: draftHandoff.status,
-      summary: draftHandoff.summary,
-      acceptanceCriteria: draftHandoff.acceptanceCriteria,
-      failure: draftHandoff.failure,
-      notes: draftHandoff.notes,
-    };
-  }
+function assertBuilderHandoffSubmission(
+  input: unknown,
+): asserts input is BuilderHandoffSubmissionInput {
+  const [error] = Value.Errors(BuilderHandoffSubmissionSchema, input);
 
-  return {
-    version: BUILDER_HANDOFF_VERSION,
-    specId: state.specId,
-    status: draftHandoff.status,
-    summary: draftHandoff.summary,
-    acceptanceCriteria: draftHandoff.acceptanceCriteria,
-    notes: draftHandoff.notes,
-  };
-};
+  if (error !== undefined)
+    throw new Error(`Invalid builder submission: ${error.message}.`);
+}
 
 type CompleteBuilderPassInput = {
   paths: MaestroPaths;
@@ -86,8 +66,14 @@ export const completeBuilderPass = async ({
     );
   }
 
+  assertBuilderHandoffSubmission(draftHandoff);
+
   const handoffInput = {
-    handoff: buildBuilderHandoff({ draftHandoff, state: currentState }),
+    handoff: {
+      ...draftHandoff,
+      version: BUILDER_HANDOFF_VERSION,
+      specId: currentState.specId,
+    },
     specId: currentState.specId,
   };
 
@@ -99,7 +85,9 @@ export const completeBuilderPass = async ({
     event:
       draftHandoff.status === BUILDER_HANDOFF_STATUSES.DONE
         ? WORKFLOW_EVENTS.BUILDER_DONE
-        : WORKFLOW_EVENTS.BUILDER_FAILED,
+        : draftHandoff.status === BUILDER_HANDOFF_STATUSES.ESCALATION
+          ? WORKFLOW_EVENTS.OPEN_ESCALATION
+          : WORKFLOW_EVENTS.BUILDER_FAILED,
   });
 
   await mkdir(paths.getBuilderHandoffsPath(specId), { recursive: true });