@emiliosp/pi-maestro 0.14.0 → 0.16.0

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

@@ -44,12 +44,13 @@ export const registerRecordSimplifierHandoffTool = (pi: ExtensionAPI): void => {
     async execute(_toolCallId, params, _signal, _onUpdate, context) {
       assertSimplifierSubmission(params);
 
-      const { paths } = await resolveWorkflowContext({
+      const { paths, config } = await resolveWorkflowContext({
         cwd: context.cwd,
         specId: params.specId,
       });
 
       const completed = await completeSimplifierPass({
+        config,
         paths,
         specId: params.specId,
         handoff: { ...params, version: SIMPLIFIER_HANDOFF_VERSION },

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

@@ -53,7 +53,7 @@ export const registerRecordVerifierHandoffTool = (pi: ExtensionAPI): void => {
     async execute(_toolCallId, params, _signal, _onUpdate, context) {
       const { specId, ...submission } = params;
 
-      const { paths } = await resolveWorkflowContext({
+      const { paths, config } = await resolveWorkflowContext({
         cwd: context.cwd,
         specId,
       });
@@ -69,11 +69,7 @@ export const registerRecordVerifierHandoffTool = (pi: ExtensionAPI): void => {
         notes: submission.notes,
       };
 
-      const completed = await completeVerifierPass({
-        paths,
-        specId,
-        handoff,
-      });
+      const completed = await completeVerifierPass({ config, paths, specId, handoff });
 
       return {
         content: [

package/src/tools/child/utils/resolveWorkflowContext.ts

@@ -16,7 +16,7 @@ export const resolveWorkflowContext = async ({ cwd, specId }: ResolveWorkflowCon
     throw new Error(`Invalid spec ID: "${specId}".`);
   }
 
-  const { paths, projectRoot } = await resolveToolRunContext(cwd);
+  const { paths, projectRoot, config } = await resolveToolRunContext(cwd);
 
-  return { paths, specId, projectRoot };
+  return { paths, specId, projectRoot, config };
 };

package/src/tools/main/mark-spec-ready.ts

@@ -10,12 +10,13 @@ import { SPEC_ID_PATTERN } from '#ids/isValidSpecId.ts';
 import maestroSessionState from '#maestro/session/MaestroSessionState.ts';
 import { resolveToolRunContext } from '#tools/utils/resolveToolRunContext.ts';
 import { markSpecReady } from '#workflow/spec/markSpecReady.ts';
+import { WORKFLOW_PHASES } from '#workflow/state/schema.ts';
 
 export const MARK_SPEC_READY_TOOL = {
   NAME: 'maestro_mark_spec_ready',
   LABEL: 'Mark Spec Ready',
   DESCRIPTION:
-    'Approve proposal.md and spec.md together with design.md if present, only from drafting-spec after the owner replies GREEN FLAG. Freeze all present documents and move to ready-for-builder. Only the owner reply GREEN FLAG authorizes approval. After this transition succeeds, call maestro_run_builder in the foreground.',
+    'Approve proposal.md and spec.md together with design.md if present, only from drafting-spec after the owner replies GREEN FLAG. Freeze all present documents and move to the configured next phase. Only the owner reply GREEN FLAG authorizes approval. Run the builder only if the returned phase is ready-for-builder; otherwise summarize the approved spec and skipped agents.',
 } as const;
 
 const MarkSpecReadyToolParameters = Type.Object(
@@ -32,9 +33,10 @@ export const registerMarkSpecReadyTool = (pi: ExtensionAPI): void => {
     description: MARK_SPEC_READY_TOOL.DESCRIPTION,
     parameters: MarkSpecReadyToolParameters,
     async execute(_toolCallId, { specId }, _signal, _onUpdate, context) {
-      const { paths } = await resolveToolRunContext(context.cwd);
+      const { paths, config } = await resolveToolRunContext(context.cwd);
 
       const state = await markSpecReady({
+        config,
         paths,
         specId,
         activeWorkflowSpecId: maestroSessionState.getActiveSpecId(),
@@ -44,7 +46,10 @@ export const registerMarkSpecReadyTool = (pi: ExtensionAPI): void => {
         content: [
           {
             type: 'text',
-            text: `Spec ${state.specId} is approved and ready-for-builder. Call maestro_run_builder now. No separate owner start request is needed.`,
+            text:
+              state.phase === WORKFLOW_PHASES.CANDIDATE_READY
+                ? `Spec ${state.specId} is approved. The workflow is candidate-ready. Builder, verifier, and simplifier skipped by configuration. No implementation or verification was performed.`
+                : `Spec ${state.specId} is approved and ready-for-builder. Call maestro_run_builder now. No separate owner start request is needed.`,
           },
         ],
         details: state,

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

@@ -47,9 +47,10 @@ export const registerResolveEscalationsTool = (pi: ExtensionAPI): void => {
     parameters: ResolveEscalationsToolParameters,
     async execute(_toolCallId, params, _signal, _onUpdate, context) {
       const { specId, specChangeRequired, decisions } = params;
-      const { paths } = await resolveToolRunContext(context.cwd);
+      const { paths, config } = await resolveToolRunContext(context.cwd);
 
       const resolved = await resolveEscalations({
+        config,
         paths,
         specId,
         specChangeRequired,

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

@@ -3,7 +3,6 @@
  * Used: When the owner invokes the resolve-findings tool.
  */
 
-import { StringEnum } from '@earendil-works/pi-ai';
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
 import { Type } from 'typebox';
 
@@ -27,7 +26,7 @@ const FindingDecisionFields = {
 const RejectFindingDecisionSchema = Type.Object(
   {
     ...FindingDecisionFields,
-    decision: StringEnum([FINDING_DECISIONS.REJECT] as const),
+    decision: Type.Enum([FINDING_DECISIONS.REJECT] as const, { type: 'string' }),
     reason: Type.String({ minLength: 1 }),
   },
   {
@@ -38,7 +37,7 @@ const RejectFindingDecisionSchema = Type.Object(
 const FixCodeFindingDecisionSchema = Type.Object(
   {
     ...FindingDecisionFields,
-    decision: StringEnum([FINDING_DECISIONS.FIX_CODE] as const),
+    decision: Type.Enum([FINDING_DECISIONS.FIX_CODE] as const, { type: 'string' }),
   },
   {
     additionalProperties: false,
@@ -48,7 +47,7 @@ const FixCodeFindingDecisionSchema = Type.Object(
 const ReviseSpecFindingDecisionSchema = Type.Object(
   {
     ...FindingDecisionFields,
-    decision: StringEnum([FINDING_DECISIONS.REVISE_SPEC] as const),
+    decision: Type.Enum([FINDING_DECISIONS.REVISE_SPEC] as const, { type: 'string' }),
     reason: Type.String({ minLength: 1, pattern: '\\S' }),
     specChange: Type.String({ minLength: 1, pattern: '\\S' }),
   },
@@ -96,6 +95,10 @@ const formatResolution = (details: FindingResolutionDetails): string => {
     return `${summary} The workflow is ready-for-builder. Run the builder separately.`;
   }
 
+  if (details.phase === WORKFLOW_PHASES.CANDIDATE_READY) {
+    return `${summary} The workflow is candidate-ready. Simplifier skipped by configuration.`;
+  }
+
   return `${summary} The workflow is simplifier-running. Call maestro_run_simplifier next with this specId, without another approval or verifier pass.`;
 };
 
@@ -106,13 +109,9 @@ export const registerResolveFindingsTool = (pi: ExtensionAPI): void => {
     description: RESOLVE_FINDINGS_TOOL.DESCRIPTION,
     parameters: ResolveFindingsToolParameters,
     async execute(_toolCallId, { specId, decisions }, _signal, _onUpdate, context) {
-      const { paths } = await resolveToolRunContext(context.cwd);
+      const { paths, config } = await resolveToolRunContext(context.cwd);
 
-      const resolved = await resolveFindings({
-        paths,
-        specId,
-        decisions,
-      });
+      const resolved = await resolveFindings({ config, paths, specId, decisions });
 
       const details: FindingResolutionDetails = {
         specId: resolved.state.specId,

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

@@ -14,19 +14,21 @@ import {
   BUILDER_HANDOFF_STATUSES,
   type BuilderHandoff,
 } from '#artifacts/builder-handoff/schema.ts';
-import { AGENTS } from '#config/schema.ts';
+import { AGENTS, type MaestroConfig } from '#config/schema.ts';
 import { SPEC_ID_PATTERN } from '#ids/isValidSpecId.ts';
 import { refreshMaestroStatus } from '#maestro/status/refreshMaestroStatus.ts';
 import type { MaestroPaths } from '#MaestroPaths.ts';
 import {
   assertDelegationResponse,
+  SUBAGENT_TIMEOUT_MS,
   waitForDelegationResponse,
 } from '#tools/utils/pi-subagent-delegation.ts';
 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 } from '#workflow/state/schema.ts';
+import { WORKFLOW_PHASES, WORKFLOW_EVENTS, type WorkflowState } from '#workflow/state/schema.ts';
+import { transitionWorkflow } from '#workflow/transitions.ts';
 
 export const RUN_BUILDER_TOOL = {
   NAME: 'maestro_run_builder',
@@ -42,13 +44,14 @@ const RunBuilderToolParameters = Type.Object(
   { additionalProperties: false },
 );
 
-const MILLISECONDS_PER_MINUTE = 60_000;
-
 type BuilderRunResult =
   | {
       outcome: typeof BUILDER_HANDOFF_STATUSES.DONE;
       specId: string;
-      phase: typeof WORKFLOW_PHASES.READY_FOR_VERIFIER;
+      phase:
+        | typeof WORKFLOW_PHASES.READY_FOR_VERIFIER
+        | typeof WORKFLOW_PHASES.SIMPLIFIER_RUNNING
+        | typeof WORKFLOW_PHASES.CANDIDATE_READY;
       handoff: BuilderHandoff;
     }
   | {
@@ -59,11 +62,15 @@ type BuilderRunResult =
     };
 
 type ReadBuilderResultInput = {
+  config: MaestroConfig;
+  builderRunningState: WorkflowState;
   paths: MaestroPaths;
   specId: string;
 };
 
 const readBuilderResult = async ({
+  config,
+  builderRunningState,
   paths,
   specId,
 }: ReadBuilderResultInput): Promise<BuilderRunResult> => {
@@ -74,20 +81,32 @@ const readBuilderResult = async ({
       throw new Error(`Workflow spec ID mismatch: expected "${specId}", found "${state.specId}".`);
     }
 
+    const donePhase = transitionWorkflow({
+      state: builderRunningState,
+      event: WORKFLOW_EVENTS.BUILDER_DONE,
+      config,
+    }).phase;
+
     if (
       state.phase !== WORKFLOW_PHASES.READY_FOR_VERIFIER &&
+      state.phase !== WORKFLOW_PHASES.SIMPLIFIER_RUNNING &&
+      state.phase !== WORKFLOW_PHASES.CANDIDATE_READY &&
       state.phase !== WORKFLOW_PHASES.ESCALATION_DECISIONS
     ) {
       throw new Error(`Builder returned with unexpected workflow phase "${state.phase}".`);
     }
 
+    if (state.phase !== WORKFLOW_PHASES.ESCALATION_DECISIONS && state.phase !== donePhase) {
+      throw new Error(`Builder returned with unexpected workflow phase "${state.phase}".`);
+    }
+
     const handoff = await readBuilderHandoff({
       path: await paths.getActiveBuilderHandoffPath(specId),
       specId,
     });
 
     const expectedStatus =
-      state.phase === WORKFLOW_PHASES.READY_FOR_VERIFIER
+      state.phase !== WORKFLOW_PHASES.ESCALATION_DECISIONS
         ? BUILDER_HANDOFF_STATUSES.DONE
         : BUILDER_HANDOFF_STATUSES.ESCALATION;
 
@@ -95,7 +114,7 @@ const readBuilderResult = async ({
       throw new Error(`Builder handoff status does not match workflow phase "${state.phase}".`);
     }
 
-    if (state.phase === WORKFLOW_PHASES.READY_FOR_VERIFIER) {
+    if (state.phase !== WORKFLOW_PHASES.ESCALATION_DECISIONS) {
       return {
         outcome: BUILDER_HANDOFF_STATUSES.DONE,
         specId,
@@ -122,11 +141,19 @@ const readBuilderResult = async ({
 };
 
 const formatBuilderResult = (result: BuilderRunResult): string => {
-  if (result.outcome === BUILDER_HANDOFF_STATUSES.DONE) {
-    return `Builder completed spec ${result.specId}. The workflow is ready-for-verifier.`;
+  if (result.outcome !== BUILDER_HANDOFF_STATUSES.DONE) {
+    return `Builder submitted escalation questions 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.`;
+  if (result.phase === WORKFLOW_PHASES.CANDIDATE_READY) {
+    return `Builder completed spec ${result.specId}. The workflow is candidate-ready. Verifier and simplifier skipped by configuration. No independent verification was performed.`;
+  }
+
+  if (result.phase === WORKFLOW_PHASES.SIMPLIFIER_RUNNING) {
+    return `Builder completed spec ${result.specId}. The workflow is simplifier-running. Verifier skipped by configuration. Call maestro_run_simplifier next.`;
+  }
+
+  return `Builder completed spec ${result.specId}. The workflow is ${result.phase}.`;
 };
 
 export const registerRunBuilderTool = (pi: ExtensionAPI): void => {
@@ -138,7 +165,12 @@ export const registerRunBuilderTool = (pi: ExtensionAPI): void => {
     async execute(toolCallId, { specId }, _signal, _onUpdate, context) {
       const { paths, config } = await resolveToolRunContext(context.cwd);
 
-      const run = await prepareBuilderRun({ paths, specId });
+      const { projectRoot, state: builderRunningState } = await prepareBuilderRun({
+        config,
+        paths,
+        specId,
+      });
+
       await refreshMaestroStatus(context);
 
       const request: SubagentDelegationRequest = {
@@ -148,12 +180,12 @@ export const registerRunBuilderTool = (pi: ExtensionAPI): void => {
         // pi-subagents loads this name from agents/builder.md through package.json.
         // See docs/subagent-integration.md.
         agent: AGENTS.BUILDER,
-        task: `Implement specId "${specId}" in the project directory "${run.projectRoot}".`,
+        task: `Implement specId "${specId}" in the project directory "${projectRoot}".`,
         context: 'fresh',
-        cwd: run.projectRoot,
+        cwd: projectRoot,
         model: config.builder.model,
         thinking: config.builder.thinking,
-        timeoutMs: config.builder.timeoutMinutes * MILLISECONDS_PER_MINUTE,
+        timeoutMs: SUBAGENT_TIMEOUT_MS,
         result: { kind: 'text' },
       };
 
@@ -163,7 +195,7 @@ export const registerRunBuilderTool = (pi: ExtensionAPI): void => {
       });
 
       assertDelegationResponse(response);
-      const result = await readBuilderResult({ paths, specId });
+      const result = await readBuilderResult({ paths, specId, config, builderRunningState });
 
       return {
         content: [{ type: 'text', text: formatBuilderResult(result) }],

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

@@ -16,6 +16,7 @@ import { refreshMaestroStatus } from '#maestro/status/refreshMaestroStatus.ts';
 import type { MaestroPaths } from '#MaestroPaths.ts';
 import {
   assertDelegationResponse,
+  SUBAGENT_TIMEOUT_MS,
   waitForDelegationResponse,
 } from '#tools/utils/pi-subagent-delegation.ts';
 import { resolveToolRunContext } from '#tools/utils/resolveToolRunContext.ts';
@@ -37,8 +38,6 @@ const RunSimplifierToolParameters = Type.Object(
   { additionalProperties: false },
 );
 
-const MILLISECONDS_PER_MINUTE = 60_000;
-
 const GIT_SKIP_WARNING = 'Simplifier skipped: Git repository unavailable.';
 
 type GitReadinessInput = {
@@ -118,6 +117,7 @@ export const registerRunSimplifierTool = (pi: ExtensionAPI): void => {
 
       if (!(await isGitReady({ pi, projectRoot }))) {
         const nextState = transitionWorkflow({
+          config,
           state,
           event: WORKFLOW_EVENTS.SIMPLIFIER_SKIPPED,
         });
@@ -146,7 +146,7 @@ export const registerRunSimplifierTool = (pi: ExtensionAPI): void => {
         cwd: projectRoot,
         model: config.simplifier.model,
         thinking: config.simplifier.thinking,
-        timeoutMs: config.simplifier.timeoutMinutes * MILLISECONDS_PER_MINUTE,
+        timeoutMs: SUBAGENT_TIMEOUT_MS,
         result: { kind: 'text' },
       };
 

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

@@ -11,18 +11,20 @@ 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 { AGENTS, type MaestroConfig } from '#config/schema.ts';
 import { SPEC_ID_PATTERN } from '#ids/isValidSpecId.ts';
 import { refreshMaestroStatus } from '#maestro/status/refreshMaestroStatus.ts';
 import type { MaestroPaths } from '#MaestroPaths.ts';
 import {
   assertDelegationResponse,
+  SUBAGENT_TIMEOUT_MS,
   waitForDelegationResponse,
 } from '#tools/utils/pi-subagent-delegation.ts';
 import { resolveToolRunContext } from '#tools/utils/resolveToolRunContext.ts';
 import { WORKFLOW_ROLES } from '#workflow/roles.ts';
 import { readWorkflowState } from '#workflow/state/readWorkflowState.ts';
-import { WORKFLOW_PHASES } from '#workflow/state/schema.ts';
+import { WORKFLOW_PHASES, WORKFLOW_EVENTS, type WorkflowState } from '#workflow/state/schema.ts';
+import { transitionWorkflow } from '#workflow/transitions.ts';
 import { prepareVerifierRun } from '#workflow/verifier/prepareVerifierRun.ts';
 
 export const RUN_VERIFIER_TOOL = {
@@ -39,9 +41,8 @@ const RunVerifierToolParameters = Type.Object(
   { additionalProperties: false },
 );
 
-const MILLISECONDS_PER_MINUTE = 60_000;
-
 type VerifierTerminalPhase =
+  | typeof WORKFLOW_PHASES.CANDIDATE_READY
   | typeof WORKFLOW_PHASES.SIMPLIFIER_RUNNING
   | typeof WORKFLOW_PHASES.FINDING_DECISIONS;
 
@@ -53,11 +54,15 @@ type VerifierRunResult = {
 };
 
 type ReadVerifierResultInput = {
+  config: MaestroConfig;
+  runningState: WorkflowState;
   paths: MaestroPaths;
   specId: string;
 };
 
 const readVerifierResult = async ({
+  config,
+  runningState,
   paths,
   specId,
 }: ReadVerifierResultInput): Promise<VerifierRunResult> => {
@@ -74,6 +79,7 @@ const readVerifierResult = async ({
 
     if (
       state.phase !== WORKFLOW_PHASES.SIMPLIFIER_RUNNING &&
+      state.phase !== WORKFLOW_PHASES.CANDIDATE_READY &&
       state.phase !== WORKFLOW_PHASES.FINDING_DECISIONS
     ) {
       throw new Error(`Verifier returned with unexpected workflow phase "${state.phase}".`);
@@ -87,7 +93,8 @@ const readVerifierResult = async ({
     const expectedPhase =
       handoff.findings.length > 0
         ? WORKFLOW_PHASES.FINDING_DECISIONS
-        : WORKFLOW_PHASES.SIMPLIFIER_RUNNING;
+        : transitionWorkflow({ state: runningState, event: WORKFLOW_EVENTS.VERIFIER_DONE, config })
+            .phase;
 
     if (state.phase !== expectedPhase) {
       throw new Error(`Verifier handoff findings do not match workflow phase "${state.phase}".`);
@@ -107,6 +114,10 @@ const readVerifierResult = async ({
 };
 
 const formatVerifierResult = (result: VerifierRunResult): string => {
+  if (result.outcome === WORKFLOW_PHASES.CANDIDATE_READY) {
+    return `Verifier completed spec ${result.specId}. The workflow is candidate-ready. Simplifier skipped by configuration.`;
+  }
+
   if (result.outcome === WORKFLOW_PHASES.SIMPLIFIER_RUNNING) {
     return `Verifier completed spec ${result.specId}. The workflow is simplifier-running. Call maestro_run_simplifier next with this specId, without another approval or verifier pass.`;
   }
@@ -123,7 +134,7 @@ export const registerRunVerifierTool = (pi: ExtensionAPI): void => {
     async execute(toolCallId, { specId }, _signal, _onUpdate, context) {
       const { paths, config } = await resolveToolRunContext(context.cwd);
 
-      const run = await prepareVerifierRun({ paths, specId });
+      const run = await prepareVerifierRun({ config, paths, specId });
       await refreshMaestroStatus(context);
 
       const request: SubagentDelegationRequest = {
@@ -137,7 +148,7 @@ export const registerRunVerifierTool = (pi: ExtensionAPI): void => {
         cwd: run.projectRoot,
         model: config.verifier.model,
         thinking: config.verifier.thinking,
-        timeoutMs: config.verifier.timeoutMinutes * MILLISECONDS_PER_MINUTE,
+        timeoutMs: SUBAGENT_TIMEOUT_MS,
         result: { kind: 'text' },
       };
 
@@ -147,7 +158,7 @@ export const registerRunVerifierTool = (pi: ExtensionAPI): void => {
       });
 
       assertDelegationResponse(response);
-      const result = await readVerifierResult({ paths, specId });
+      const result = await readVerifierResult({ paths, specId, config, runningState: run.state });
 
       return {
         content: [{ type: 'text', text: formatVerifierResult(result) }],

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

@@ -13,6 +13,9 @@ import {
 
 // pi-subagents exports SubagentDelegationStatus as a type, not runtime values.
 // TypeScript erases the type, so the adapter needs these constants for comparisons.
+// Fixed deadline passed to pi-subagents in place of the removed per-agent timeout configuration.
+export const SUBAGENT_TIMEOUT_MS = 9_999 * 60_000;
+
 export const DELEGATION_STATUSES = {
   COMPLETED: 'completed',
   FAILED: 'failed',

package/src/workflow/builder/completeBuilderPass.ts

@@ -15,6 +15,7 @@ import {
   BuilderHandoffSubmissionSchema,
 } from '#artifacts/builder-handoff/schema.ts';
 import { writeBuilderHandoff } from '#artifacts/builder-handoff/writeBuilderHandoff.ts';
+import type { MaestroConfig } from '#config/schema.ts';
 import type { MaestroPaths } from '#MaestroPaths.ts';
 import { getWorkflowEventByBuilderHandoff } from '#workflow/builder/utils/getWorkflowEventByBuilderHandoff.ts';
 import { readWorkflowState } from '#workflow/state/readWorkflowState.ts';
@@ -39,12 +40,14 @@ function assertBuilderHandoffSubmission(
 }
 
 type CompleteBuilderPassInput = {
+  config: MaestroConfig;
   paths: MaestroPaths;
   specId: string;
   handoff: BuilderHandoffSubmissionInput;
 };
 
 export const completeBuilderPass = async ({
+  config,
   paths,
   specId,
   handoff: draftHandoff,
@@ -84,6 +87,7 @@ export const completeBuilderPass = async ({
   });
 
   const nextState = transitionWorkflow({
+    config,
     state: currentState,
     event: getWorkflowEventByBuilderHandoff(handoff),
   });

package/src/workflow/builder/prepareBuilderRun.ts

@@ -3,15 +3,17 @@
  * Used: Before Maestro runs a builder pass.
  */
 
+import type { MaestroConfig } from '#config/schema.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';
+import { WORKFLOW_EVENTS, WORKFLOW_PHASES, type WorkflowState } from '#workflow/state/schema.ts';
 import { writeWorkflowState } from '#workflow/state/writeWorkflowState.ts';
 import { transitionWorkflow } from '#workflow/transitions.ts';
 
 export type BuilderRun = {
+  state: WorkflowState;
   specId: string;
   projectRoot: string;
 };
@@ -38,11 +40,13 @@ async function assertBuilderRunBase({ paths, specId }: AssertBuilderRunBaseInput
 }
 
 type PrepareBuilderRunInput = {
+  config: MaestroConfig;
   paths: MaestroPaths;
   specId: string;
 };
 
 export const prepareBuilderRun = async ({
+  config,
   paths,
   specId,
 }: PrepareBuilderRunInput): Promise<BuilderRun> => {
@@ -60,6 +64,7 @@ export const prepareBuilderRun = async ({
   const currentState = await readWorkflowState(workflowPath);
 
   const nextState = transitionWorkflow({
+    config,
     state: currentState,
     event: WORKFLOW_EVENTS.RUN_BUILDER,
   });
@@ -70,6 +75,7 @@ export const prepareBuilderRun = async ({
   });
 
   return {
+    state: nextState,
     specId,
     projectRoot: paths.getProjectRoot(),
   };

package/src/workflow/builder/resolveEscalations.ts

@@ -10,6 +10,7 @@ import {
   type EscalationResolution,
 } from '#artifacts/builder-handoff/schema.ts';
 import { writeBuilderHandoff } from '#artifacts/builder-handoff/writeBuilderHandoff.ts';
+import type { MaestroConfig } from '#config/schema.ts';
 import type { MaestroPaths } from '#MaestroPaths.ts';
 import { getWorkflowEventBySpecChangeRequired } from '#workflow/builder/utils/getWorkflowEventBySpecChangeRequired.ts';
 import { readWorkflowState } from '#workflow/state/readWorkflowState.ts';
@@ -57,6 +58,7 @@ const applyEscalationDecisions = ({ escalations, decisions }: ApplyEscalationDec
 };
 
 type ResolveEscalationsInput = {
+  config: MaestroConfig;
   paths: MaestroPaths;
   specId: string;
   specChangeRequired: boolean;
@@ -64,6 +66,7 @@ type ResolveEscalationsInput = {
 };
 
 export const resolveEscalations = async ({
+  config,
   paths,
   specId,
   specChangeRequired,
@@ -95,6 +98,7 @@ export const resolveEscalations = async ({
   const nextHandoff = { ...handoff, escalations };
 
   const nextState = transitionWorkflow({
+    config,
     state,
     event: getWorkflowEventBySpecChangeRequired(specChangeRequired),
   });

package/src/workflow/simplifier/completeSimplifierPass.ts

@@ -7,6 +7,7 @@ import { mkdir } from 'node:fs/promises';
 import { dirname } from 'node:path';
 
 import { assertSimplifierHandoff } from '#artifacts/simplifier-handoff/assertSimplifierHandoff.ts';
+import type { MaestroConfig } from '#config/schema.ts';
 import type { MaestroPaths } from '#MaestroPaths.ts';
 import { writeJson } from '#utils/write-json.ts';
 import { readWorkflowState } from '#workflow/state/readWorkflowState.ts';
@@ -15,12 +16,14 @@ import { writeWorkflowState } from '#workflow/state/writeWorkflowState.ts';
 import { transitionWorkflow } from '#workflow/transitions.ts';
 
 type CompleteSimplifierPassInput = {
+  config: MaestroConfig;
   paths: MaestroPaths;
   specId: string;
   handoff: unknown;
 };
 
 export const completeSimplifierPass = async ({
+  config,
   paths,
   specId,
   handoff,
@@ -46,6 +49,7 @@ export const completeSimplifierPass = async ({
   await writeJson({ path: handoffPath, data: input.handoff });
 
   const nextState = transitionWorkflow({
+    config,
     state,
     event: WORKFLOW_EVENTS.SIMPLIFIER_DONE,
   });

package/src/workflow/spec/markSpecReady.ts

@@ -5,6 +5,7 @@
 
 import { readFile } from 'node:fs/promises';
 
+import type { MaestroConfig } from '#config/schema.ts';
 import type { MaestroPaths } from '#MaestroPaths.ts';
 import { pathExists } from '#utils/path-exists.ts';
 import { readWorkflowState } from '#workflow/state/readWorkflowState.ts';
@@ -22,12 +23,14 @@ function assertAcceptanceCriterionOrdering(markdown: string): void {
 }
 
 type MarkSpecReadyInput = {
+  config: MaestroConfig;
   paths: MaestroPaths;
   specId: string;
   activeWorkflowSpecId: string | null;
 };
 
 export const markSpecReady = async ({
+  config,
   paths,
   specId,
   activeWorkflowSpecId,
@@ -62,6 +65,7 @@ export const markSpecReady = async ({
   }
 
   const state = transitionWorkflow({
+    config,
     state: current,
     event: WORKFLOW_EVENTS.MARK_SPEC_READY,
   });