@emiliosp/pi-maestro 0.10.1 → 0.11.0

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

@@ -40,7 +40,7 @@ const RunVerifierToolParameters = Type.Object(
 const MILLISECONDS_PER_MINUTE = 60_000;
 
 type VerifierTerminalPhase =
-  | typeof WORKFLOW_PHASES.CANDIDATE_READY
+  | typeof WORKFLOW_PHASES.SIMPLIFIER_RUNNING
   | typeof WORKFLOW_PHASES.FINDING_DECISIONS;
 
 type VerifierRunResult = {
@@ -62,7 +62,7 @@ const readTerminalVerifierResult = async ({
   state,
 }: ReadTerminalVerifierResultInput): Promise<VerifierRunResult> => {
   if (
-    state.phase !== WORKFLOW_PHASES.CANDIDATE_READY &&
+    state.phase !== WORKFLOW_PHASES.SIMPLIFIER_RUNNING &&
     state.phase !== WORKFLOW_PHASES.FINDING_DECISIONS
   ) {
     throw new Error(
@@ -78,7 +78,7 @@ const readTerminalVerifierResult = async ({
   const expectedPhase =
     handoff.findings.length > 0
       ? WORKFLOW_PHASES.FINDING_DECISIONS
-      : WORKFLOW_PHASES.CANDIDATE_READY;
+      : WORKFLOW_PHASES.SIMPLIFIER_RUNNING;
 
   if (state.phase !== expectedPhase) {
     throw new Error(
@@ -131,8 +131,8 @@ 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.`;
+  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.`;
   }
 
   return `Verifier found ${result.handoff.findings.length} finding(s) for spec ${result.specId}. The workflow is waiting for owner decisions.`;

package/src/workflow/roles.ts

@@ -1,11 +1,12 @@
 /**
  * Objective: Define the roles used by the Maestro workflow.
- * Used: When workflow code identifies builder and verifier responsibilities.
+ * Used: When workflow code identifies agent responsibilities.
  */
 
 export const WORKFLOW_ROLES = {
   BUILDER: 'builder',
   VERIFIER: 'verifier',
+  SIMPLIFIER: 'simplifier',
 } as const;
 
 export type WorkflowRole = (typeof WORKFLOW_ROLES)[keyof typeof WORKFLOW_ROLES];

package/src/workflow/simplifier/completeSimplifierPass.ts

@@ -0,0 +1,57 @@
+/**
+ * Objective: Save a validated simplifier handoff before completing the workflow.
+ * Used: When the simplifier records its single result.
+ */
+
+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';
+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';
+
+type CompleteSimplifierPassInput = {
+  paths: MaestroPaths;
+  specId: string;
+  handoff: unknown;
+};
+
+export const completeSimplifierPass = async ({
+  paths,
+  specId,
+  handoff,
+}: CompleteSimplifierPassInput) => {
+  const workflowPath = paths.getWorkflowPath(specId);
+  const state = await readWorkflowState(workflowPath);
+
+  if (state.specId !== specId) {
+    throw new Error(
+      `Workflow spec ID mismatch: expected "${specId}", found "${state.specId}".`,
+    );
+  }
+
+  if (state.phase !== WORKFLOW_PHASES.SIMPLIFIER_RUNNING) {
+    throw new Error(
+      `Simplifier handoff requires simplifier-running state, found "${state.phase}".`,
+    );
+  }
+
+  const input = { handoff, specId, projectRoot: paths.getProjectRoot() };
+  assertSimplifierHandoff(input);
+
+  const handoffPath = paths.getSimplifierHandoffPath(specId);
+  await mkdir(dirname(handoffPath), { recursive: true });
+  await writeJson({ path: handoffPath, data: input.handoff });
+
+  const nextState = transitionWorkflow({
+    state,
+    event: WORKFLOW_EVENTS.SIMPLIFIER_DONE,
+  });
+
+  await writeWorkflowState({ path: workflowPath, state: nextState });
+
+  return { handoff: input.handoff, handoffPath, state: nextState };
+};

package/src/workflow/state/schema.ts

@@ -17,6 +17,7 @@ export const WORKFLOW_PHASES = {
   READY_FOR_VERIFIER: 'ready-for-verifier',
   VERIFIER_RUNNING: 'verifier-running',
   FINDING_DECISIONS: 'finding-decisions',
+  SIMPLIFIER_RUNNING: 'simplifier-running',
   CANDIDATE_READY: 'candidate-ready',
 } as const;
 
@@ -30,6 +31,8 @@ export const WORKFLOW_EVENTS = {
   RUN_VERIFIER: 'run-verifier',
   VERIFIER_FOUND_FINDINGS: 'verifier-found-findings',
   VERIFIER_DONE: 'verifier-done',
+  SIMPLIFIER_DONE: 'simplifier-done',
+  SIMPLIFIER_SKIPPED: 'simplifier-skipped',
   OWNER_REJECT_FINDINGS: 'owner-reject-findings',
   OWNER_REQUEST_FIXES: 'owner-request-fixes',
 } as const;
@@ -42,6 +45,7 @@ export const WorkflowPhaseSchema = Type.Union([
   Type.Literal(WORKFLOW_PHASES.READY_FOR_VERIFIER),
   Type.Literal(WORKFLOW_PHASES.VERIFIER_RUNNING),
   Type.Literal(WORKFLOW_PHASES.FINDING_DECISIONS),
+  Type.Literal(WORKFLOW_PHASES.SIMPLIFIER_RUNNING),
   Type.Literal(WORKFLOW_PHASES.CANDIDATE_READY),
 ]);
 

package/src/workflow/transitions.ts

@@ -55,10 +55,18 @@ export const WORKFLOW_TRANSITIONS: Record<WorkflowEvent, WorkflowTransition> = {
   },
   [WORKFLOW_EVENTS.VERIFIER_DONE]: {
     from: [WORKFLOW_PHASES.VERIFIER_RUNNING],
-    to: WORKFLOW_PHASES.CANDIDATE_READY,
+    to: WORKFLOW_PHASES.SIMPLIFIER_RUNNING,
   },
   [WORKFLOW_EVENTS.OWNER_REJECT_FINDINGS]: {
     from: [WORKFLOW_PHASES.FINDING_DECISIONS],
+    to: WORKFLOW_PHASES.SIMPLIFIER_RUNNING,
+  },
+  [WORKFLOW_EVENTS.SIMPLIFIER_DONE]: {
+    from: [WORKFLOW_PHASES.SIMPLIFIER_RUNNING],
+    to: WORKFLOW_PHASES.CANDIDATE_READY,
+  },
+  [WORKFLOW_EVENTS.SIMPLIFIER_SKIPPED]: {
+    from: [WORKFLOW_PHASES.SIMPLIFIER_RUNNING],
     to: WORKFLOW_PHASES.CANDIDATE_READY,
   },
   [WORKFLOW_EVENTS.OWNER_REQUEST_FIXES]: {

package/src/workflow/utils/getAgentRole.ts

@@ -1,6 +1,6 @@
 /**
  * Objective: Resolve the agent responsible for a workflow phase.
- * Used: When workflow logic maps persisted phases to builder or verifier roles.
+ * Used: When workflow logic maps persisted phases to agent roles.
  */
 
 import type { WorkflowRole } from '#workflow/roles.ts';
@@ -29,5 +29,9 @@ export const getAgentRole = (
     return WORKFLOW_ROLES.VERIFIER;
   }
 
+  if (phase === WORKFLOW_PHASES.SIMPLIFIER_RUNNING) {
+    return WORKFLOW_ROLES.SIMPLIFIER;
+  }
+
   return null;
 };