@emiliosp/pi-maestro 0.1.1 → 0.1.2

package/src/workflow/builder/{prepareBuilderLauncher.ts → prepareBuilderRun.ts}

@@ -1,6 +1,6 @@
 /**
- * Objective: Prepare a committed builder launch checkpoint in the current checkout.
- * Used: Before Maestro launches a builder pass.
+ * Objective: Prepare a committed builder run checkpoint in the current checkout.
+ * Used: Before Maestro runs a builder pass.
  */
 
 import { rm } from 'node:fs/promises';
@@ -14,22 +14,22 @@ import { WORKFLOW_EVENTS, WORKFLOW_PHASES } from '#workflow/state/schema.ts';
 import { writeWorkflowState } from '#workflow/state/writeWorkflowState.ts';
 import { transitionWorkflow } from '#workflow/transitions.ts';
 
-export type BuilderLaunch = {
+export type BuilderRun = {
   specId: string;
   revision: number;
   repositoryRoot: string;
   checkpointCommit: string;
 };
 
-type AssertBuilderLaunchBaseInput = {
+type AssertBuilderRunBaseInput = {
   paths: MaestroPaths;
   specId: string;
 };
 
-async function assertBuilderLaunchBase({
+async function assertBuilderRunBase({
   paths,
   specId,
-}: AssertBuilderLaunchBaseInput): Promise<void> {
+}: AssertBuilderRunBaseInput): Promise<void> {
   const state = await readWorkflowState(paths.getWorkflowPath(specId));
 
   if (state.specId !== specId) {
@@ -39,13 +39,13 @@ async function assertBuilderLaunchBase({
   }
 
   if (state.phase !== WORKFLOW_PHASES.READY_FOR_BUILDER) {
-    throw new Error(`Builder launch is not valid from phase "${state.phase}".`);
+    throw new Error(`Builder run is not valid from phase "${state.phase}".`);
   }
 
   const status = await getRepositoryStatus(paths.getRepositoryRoot());
 
   if (!status.clean) {
-    throw new Error('Builder launch requires a clean current checkout.');
+    throw new Error('Builder run requires a clean current checkout.');
   }
 
   if (!(await pathExists(paths.getSpecFilePath(specId)))) {
@@ -53,24 +53,24 @@ async function assertBuilderLaunchBase({
   }
 }
 
-type PrepareBuilderLaunchInput = {
+type PrepareBuilderRunInput = {
   paths: MaestroPaths;
   specId: string;
 };
 
-export const prepareBuilderLaunch = async ({
+export const prepareBuilderRun = async ({
   paths,
   specId,
-}: PrepareBuilderLaunchInput): Promise<BuilderLaunch> => {
+}: PrepareBuilderRunInput): Promise<BuilderRun> => {
   const activeSpecId = maestroSessionState.getActiveSpecId();
 
   if (activeSpecId !== specId) {
     throw new Error(
-      `Builder launch requires active Maestro spec "${specId}", found "${activeSpecId ?? 'none'}".`,
+      `Builder run requires active Maestro spec "${specId}", found "${activeSpecId ?? 'none'}".`,
     );
   }
 
-  await assertBuilderLaunchBase({ paths, specId });
+  await assertBuilderRunBase({ paths, specId });
 
   const workflowPath = paths.getWorkflowPath(specId);
   const handoffPath = paths.getBuilderHandoffPath(specId);
@@ -83,7 +83,7 @@ export const prepareBuilderLaunch = async ({
 
   const nextState = transitionWorkflow({
     state: currentState,
-    event: WORKFLOW_EVENTS.LAUNCH_BUILDER,
+    event: WORKFLOW_EVENTS.RUN_BUILDER,
   });
 
   await writeWorkflowState({

package/src/workflow/state/schema.ts

@@ -23,13 +23,12 @@ export const WORKFLOW_PHASES = {
 
 export const WORKFLOW_EVENTS = {
   MARK_SPEC_READY: 'mark-spec-ready',
-  LAUNCH_BUILDER: 'launch-builder',
+  RUN_BUILDER: 'run-builder',
   OPEN_ESCALATION: 'open-escalation',
   RESOLVE_ESCALATION: 'resolve-escalation',
   BUILDER_FAILED: 'builder-failed',
   BUILDER_DONE: 'builder-done',
-  LAUNCH_VERIFIER: 'launch-verifier',
-  RETRY_VERIFIER: 'retry-verifier',
+  RUN_VERIFIER: 'run-verifier',
   VERIFIER_FOUND_FINDINGS: 'verifier-found-findings',
   VERIFIER_APPROVED: 'verifier-approved',
   REJECT_FINDINGS: 'reject-findings',

package/src/workflow/transitions.ts

@@ -26,7 +26,7 @@ export const WORKFLOW_TRANSITIONS: Record<WorkflowEvent, WorkflowTransition> = {
     ],
     to: WORKFLOW_PHASES.READY_FOR_BUILDER,
   },
-  [WORKFLOW_EVENTS.LAUNCH_BUILDER]: {
+  [WORKFLOW_EVENTS.RUN_BUILDER]: {
     from: [WORKFLOW_PHASES.READY_FOR_BUILDER],
     to: WORKFLOW_PHASES.BUILDER_RUNNING,
   },
@@ -46,14 +46,10 @@ export const WORKFLOW_TRANSITIONS: Record<WorkflowEvent, WorkflowTransition> = {
     from: [WORKFLOW_PHASES.BUILDER_RUNNING],
     to: WORKFLOW_PHASES.READY_FOR_VERIFIER,
   },
-  [WORKFLOW_EVENTS.LAUNCH_VERIFIER]: {
+  [WORKFLOW_EVENTS.RUN_VERIFIER]: {
     from: [WORKFLOW_PHASES.READY_FOR_VERIFIER],
     to: WORKFLOW_PHASES.VERIFIER_RUNNING,
   },
-  [WORKFLOW_EVENTS.RETRY_VERIFIER]: {
-    from: [WORKFLOW_PHASES.VERIFIER_RUNNING],
-    to: WORKFLOW_PHASES.VERIFIER_RUNNING,
-  },
   [WORKFLOW_EVENTS.VERIFIER_FOUND_FINDINGS]: {
     from: [WORKFLOW_PHASES.VERIFIER_RUNNING],
     to: WORKFLOW_PHASES.FINDINGS_DECISION,

package/src/workflow/verifier/{prepareVerifierLaunch.ts → prepareVerifierRun.ts}

@@ -1,21 +1,20 @@
 /**
- * Objective: Prepare a committed verifier launch checkpoint in the current checkout.
+ * Objective: Prepare a committed verifier run checkpoint in the current checkout.
  * Used: When Maestro starts a verifier pass.
  */
 
 import { rm } from 'node:fs/promises';
 import { createWorkflowCheckpointCommit } from '#git/commits/createWorkflowCheckpointCommit.ts';
-import { getParentCommit } from '#git/history/getParentCommit.ts';
-import { getHeadCommit } from '#git/repository/getHeadCommit.ts';
 import { getRepositoryStatus } from '#git/repository/getRepositoryStatus.ts';
 import type { MaestroPaths } from '#MaestroPaths.ts';
+import maestroSessionState from '#maestro/session/MaestroSessionState.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 { writeWorkflowState } from '#workflow/state/writeWorkflowState.ts';
 import { transitionWorkflow } from '#workflow/transitions.ts';
 
-export type VerifierLaunch = {
+export type VerifierRun = {
   specId: string;
   repositoryRoot: string;
   candidateCommit: string;
@@ -23,15 +22,15 @@ export type VerifierLaunch = {
   revision: number;
 };
 
-type PrepareVerifierLaunchInput = {
+type PrepareVerifierRunInput = {
   paths: MaestroPaths;
   specId: string;
 };
 
-export const prepareVerifierLaunch = async ({
+export const prepareVerifierRun = async ({
   paths,
   specId,
-}: PrepareVerifierLaunchInput): Promise<VerifierLaunch> => {
+}: PrepareVerifierRunInput): Promise<VerifierRun> => {
   const repositoryRoot = paths.getRepositoryRoot();
   const workflowPath = paths.getWorkflowPath(specId);
   const handoffPath = paths.getVerifierHandoffPath(specId);
@@ -45,7 +44,7 @@ export const prepareVerifierLaunch = async ({
 
   if (currentState.phase !== WORKFLOW_PHASES.READY_FOR_VERIFIER) {
     throw new Error(
-      `Verifier launch requires ready-for-verifier state, found "${currentState.phase}".`,
+      `Verifier run requires ready-for-verifier state, found "${currentState.phase}".`,
     );
   }
 
@@ -53,13 +52,13 @@ export const prepareVerifierLaunch = async ({
 
   if (!status.clean) {
     throw new Error(
-      'Verifier launch requires a committed ready-for-verifier candidate.',
+      'Verifier run requires a committed ready-for-verifier candidate.',
     );
   }
 
   const nextState = transitionWorkflow({
     state: currentState,
-    event: WORKFLOW_EVENTS.LAUNCH_VERIFIER,
+    event: WORKFLOW_EVENTS.RUN_VERIFIER,
   });
 
   const handoffExists = await pathExists(handoffPath);
@@ -80,28 +79,17 @@ export const prepareVerifierLaunch = async ({
     expectedPaths.push(handoffPath);
   }
 
-  const previousHead = await getHeadCommit(repositoryRoot);
-
   const checkpointCommit = await createWorkflowCheckpointCommit({
     repositoryRoot,
     expectedPaths,
   });
 
-  const candidateCommit = await getParentCommit({
-    repositoryRoot,
-    commit: checkpointCommit,
-  });
-
-  if (candidateCommit !== previousHead) {
-    throw new Error(
-      'Verifier candidate changed while creating its checkpoint.',
-    );
-  }
+  maestroSessionState.setVerifierCheckpointCommit(checkpointCommit);
 
   return {
     specId,
     repositoryRoot,
-    candidateCommit,
+    candidateCommit: checkpointCommit,
     checkpointCommit,
     revision: nextState.revision,
   };