@emiliosp/pi-maestro 0.9.5 → 0.10.1

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

@@ -39,22 +39,17 @@ const RunVerifierToolParameters = Type.Object(
 
 const MILLISECONDS_PER_MINUTE = 60_000;
 
-type CandidateReadyResult = {
-  outcome: typeof WORKFLOW_PHASES.CANDIDATE_READY;
-  specId: string;
-  phase: typeof WORKFLOW_PHASES.CANDIDATE_READY;
-  handoff: VerifierHandoff;
-};
+type VerifierTerminalPhase =
+  | typeof WORKFLOW_PHASES.CANDIDATE_READY
+  | typeof WORKFLOW_PHASES.FINDING_DECISIONS;
 
-type FindingsResult = {
-  outcome: typeof WORKFLOW_PHASES.FINDINGS_DECISION;
+type VerifierRunResult = {
+  outcome: VerifierTerminalPhase;
   specId: string;
-  phase: typeof WORKFLOW_PHASES.FINDINGS_DECISION;
+  phase: VerifierTerminalPhase;
   handoff: VerifierHandoff;
 };
 
-type VerifierRunResult = CandidateReadyResult | FindingsResult;
-
 type ReadTerminalVerifierResultInput = {
   paths: MaestroPaths;
   specId: string;
@@ -65,12 +60,10 @@ const readTerminalVerifierResult = async ({
   paths,
   specId,
   state,
-}: ReadTerminalVerifierResultInput): Promise<
-  CandidateReadyResult | FindingsResult
-> => {
+}: ReadTerminalVerifierResultInput): Promise<VerifierRunResult> => {
   if (
     state.phase !== WORKFLOW_PHASES.CANDIDATE_READY &&
-    state.phase !== WORKFLOW_PHASES.FINDINGS_DECISION
+    state.phase !== WORKFLOW_PHASES.FINDING_DECISIONS
   ) {
     throw new Error(
       `Verifier returned with unexpected workflow phase "${state.phase}".`,
@@ -84,7 +77,7 @@ const readTerminalVerifierResult = async ({
 
   const expectedPhase =
     handoff.findings.length > 0
-      ? WORKFLOW_PHASES.FINDINGS_DECISION
+      ? WORKFLOW_PHASES.FINDING_DECISIONS
       : WORKFLOW_PHASES.CANDIDATE_READY;
 
   if (state.phase !== expectedPhase) {
@@ -93,16 +86,12 @@ const readTerminalVerifierResult = async ({
     );
   }
 
-  const details = {
+  return {
     specId,
     handoff,
+    outcome: state.phase,
+    phase: state.phase,
   };
-
-  if (state.phase === WORKFLOW_PHASES.CANDIDATE_READY) {
-    return { ...details, outcome: state.phase, phase: state.phase };
-  }
-
-  return { ...details, outcome: state.phase, phase: state.phase };
 };
 
 type ReadVerifierResultInput = {

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

@@ -17,9 +17,8 @@ export const isPathWithinOrEqual = ({
   const pathToCandidate = relative(parent, candidate);
 
   return (
-    pathToCandidate === '' ||
-    (!pathToCandidate.startsWith(`..${sep}`) &&
-      pathToCandidate !== '..' &&
-      !isAbsolute(pathToCandidate))
+    !pathToCandidate.startsWith(`..${sep}`) &&
+    pathToCandidate !== '..' &&
+    !isAbsolute(pathToCandidate)
   );
 };

package/src/workflow/builder/resolveEscalations.ts

@@ -1,17 +1,19 @@
 /**
  * Objective: Save all owner resolutions in the active builder handoff.
- * Used: When the owner keeps the contract and resolves current questions together.
+ * Used: When the owner resolves current questions, with or without spec revision.
  */
 
 import { readBuilderHandoff } from '#artifacts/builder-handoff/readBuilderHandoff.ts';
 import {
   BUILDER_HANDOFF_STATUSES,
+  type Escalation,
   type EscalationResolution,
 } from '#artifacts/builder-handoff/schema.ts';
 import { writeBuilderHandoff } from '#artifacts/builder-handoff/writeBuilderHandoff.ts';
 import type { MaestroPaths } from '#MaestroPaths.ts';
+import { getWorkflowEventBySpecChangeRequired } from '#workflow/builder/utils/getWorkflowEventBySpecChangeRequired.ts';
 import { readWorkflowState } from '#workflow/state/readWorkflowState.ts';
-import { WORKFLOW_EVENTS, WORKFLOW_PHASES } from '#workflow/state/schema.ts';
+import { WORKFLOW_PHASES } from '#workflow/state/schema.ts';
 import { writeWorkflowState } from '#workflow/state/writeWorkflowState.ts';
 import { transitionWorkflow } from '#workflow/transitions.ts';
 
@@ -19,43 +21,23 @@ export type EscalationDecision = EscalationResolution & {
   escalationId: string;
 };
 
-type ResolveEscalationsInput = {
-  paths: MaestroPaths;
-  specId: string;
+type ApplyEscalationDecisionsInput = {
+  escalations: Escalation[];
   decisions: EscalationDecision[];
 };
 
-export const resolveEscalations = async ({
-  paths,
-  specId,
+const applyEscalationDecisions = ({
+  escalations,
   decisions,
-}: ResolveEscalationsInput) => {
-  const workflowPath = paths.getWorkflowPath(specId);
-  const state = await readWorkflowState(workflowPath);
-
-  if (state.specId !== specId) throw new Error('Workflow spec ID mismatch.');
-
-  if (state.phase !== WORKFLOW_PHASES.ESCALATION_DECISION) {
-    throw new Error(
-      `Escalation resolution requires escalation-decision state, found "${state.phase}".`,
-    );
-  }
-
-  const handoffPath = await paths.getActiveBuilderHandoffPath(specId);
-  const handoff = await readBuilderHandoff({ path: handoffPath, specId });
-
-  if (handoff.status !== BUILDER_HANDOFF_STATUSES.ESCALATION) {
-    throw new Error('Escalation resolution requires an escalation handoff.');
-  }
-
-  if (handoff.escalations.some(({ resolution }) => resolution !== null)) {
+}: 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.');
 
-  const expectedIds = new Set(handoff.escalations.map(({ id }) => id));
+  const expectedIds = new Set(escalations.map(({ id }) => id));
   const resolutions = new Map<string, EscalationResolution>();
 
   for (const { escalationId, ...resolution } of decisions) {
@@ -68,7 +50,7 @@ export const resolveEscalations = async ({
     resolutions.set(escalationId, resolution);
   }
 
-  const escalations = handoff.escalations.map((escalation) => {
+  return escalations.map((escalation) => {
     const resolution = resolutions.get(escalation.id);
 
     if (resolution === undefined)
@@ -76,12 +58,49 @@ export const resolveEscalations = async ({
 
     return { ...escalation, resolution };
   });
+};
+
+type ResolveEscalationsInput = {
+  paths: MaestroPaths;
+  specId: string;
+  specChangeRequired: boolean;
+  decisions: EscalationDecision[];
+};
+
+export const resolveEscalations = async ({
+  paths,
+  specId,
+  specChangeRequired,
+  decisions,
+}: ResolveEscalationsInput) => {
+  const workflowPath = paths.getWorkflowPath(specId);
+  const state = await readWorkflowState(workflowPath);
+
+  if (state.specId !== specId) throw new Error('Workflow spec ID mismatch.');
+
+  if (state.phase !== WORKFLOW_PHASES.ESCALATION_DECISIONS) {
+    throw new Error(
+      `Escalation resolution requires escalation-decisions state, found "${state.phase}".`,
+    );
+  }
+
+  const handoffPath = await paths.getActiveBuilderHandoffPath(specId);
+  const handoff = await readBuilderHandoff({ path: handoffPath, specId });
+
+  if (handoff.status !== BUILDER_HANDOFF_STATUSES.ESCALATION) {
+    throw new Error('Escalation resolution requires an escalation handoff.');
+  }
+
+  const escalations = applyEscalationDecisions({
+    escalations: handoff.escalations,
+    decisions,
+  });
 
   const nextHandoff = { ...handoff, escalations };
 
   const nextState = transitionWorkflow({
     state,
-    event: WORKFLOW_EVENTS.RESOLVE_ESCALATION,
+    event: getWorkflowEventBySpecChangeRequired(specChangeRequired),
   });
 
   // The artifact writer validates every resolution before the first protocol write.

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

@@ -17,7 +17,7 @@ export const getWorkflowEventByBuilderHandoff = ({
   }
 
   if (status === BUILDER_HANDOFF_STATUSES.ESCALATION) {
-    return WORKFLOW_EVENTS.OPEN_ESCALATION;
+    return WORKFLOW_EVENTS.BUILDER_OPEN_ESCALATIONS;
   }
 
   throw new Error(`Unexpected builder handoff status: "${status}".`);

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

@@ -0,0 +1,16 @@
+/**
+ * Objective: Select the workflow event for resolving escalations.
+ * Used: When owner answers determine whether the spec must change.
+ */
+
+import { WORKFLOW_EVENTS, type WorkflowEvent } from '#workflow/state/schema.ts';
+
+export const getWorkflowEventBySpecChangeRequired = (
+  specChangeRequired: boolean,
+): WorkflowEvent => {
+  if (specChangeRequired) {
+    return WORKFLOW_EVENTS.OWNER_REQUEST_SPEC_REVISION;
+  }
+
+  return WORKFLOW_EVENTS.RESOLVE_ESCALATIONS;
+};

package/src/workflow/state/schema.ts

@@ -13,34 +13,35 @@ export const WORKFLOW_PHASES = {
   DRAFTING_SPEC: 'drafting-spec',
   READY_FOR_BUILDER: 'ready-for-builder',
   BUILDER_RUNNING: 'builder-running',
-  ESCALATION_DECISION: 'escalation-decision',
+  ESCALATION_DECISIONS: 'escalation-decisions',
   READY_FOR_VERIFIER: 'ready-for-verifier',
   VERIFIER_RUNNING: 'verifier-running',
-  FINDINGS_DECISION: 'findings-decision',
+  FINDING_DECISIONS: 'finding-decisions',
   CANDIDATE_READY: 'candidate-ready',
 } as const;
 
 export const WORKFLOW_EVENTS = {
   MARK_SPEC_READY: 'mark-spec-ready',
   RUN_BUILDER: 'run-builder',
-  OPEN_ESCALATION: 'open-escalation',
-  RESOLVE_ESCALATION: 'resolve-escalation',
+  BUILDER_OPEN_ESCALATIONS: 'builder-open-escalations',
+  RESOLVE_ESCALATIONS: 'resolve-escalations',
+  OWNER_REQUEST_SPEC_REVISION: 'owner-request-spec-revision',
   BUILDER_DONE: 'builder-done',
   RUN_VERIFIER: 'run-verifier',
   VERIFIER_FOUND_FINDINGS: 'verifier-found-findings',
-  VERIFIER_APPROVED: 'verifier-approved',
-  REJECT_FINDINGS: 'reject-findings',
-  REQUEST_FIXES: 'request-fixes',
+  VERIFIER_DONE: 'verifier-done',
+  OWNER_REJECT_FINDINGS: 'owner-reject-findings',
+  OWNER_REQUEST_FIXES: 'owner-request-fixes',
 } as const;
 
 export const WorkflowPhaseSchema = Type.Union([
   Type.Literal(WORKFLOW_PHASES.DRAFTING_SPEC),
   Type.Literal(WORKFLOW_PHASES.READY_FOR_BUILDER),
   Type.Literal(WORKFLOW_PHASES.BUILDER_RUNNING),
-  Type.Literal(WORKFLOW_PHASES.ESCALATION_DECISION),
+  Type.Literal(WORKFLOW_PHASES.ESCALATION_DECISIONS),
   Type.Literal(WORKFLOW_PHASES.READY_FOR_VERIFIER),
   Type.Literal(WORKFLOW_PHASES.VERIFIER_RUNNING),
-  Type.Literal(WORKFLOW_PHASES.FINDINGS_DECISION),
+  Type.Literal(WORKFLOW_PHASES.FINDING_DECISIONS),
   Type.Literal(WORKFLOW_PHASES.CANDIDATE_READY),
 ]);
 

package/src/workflow/transitions.ts

@@ -19,25 +19,28 @@ type WorkflowTransition = {
 
 export const WORKFLOW_TRANSITIONS: Record<WorkflowEvent, WorkflowTransition> = {
   [WORKFLOW_EVENTS.MARK_SPEC_READY]: {
-    from: [
-      WORKFLOW_PHASES.DRAFTING_SPEC,
-      WORKFLOW_PHASES.ESCALATION_DECISION,
-      WORKFLOW_PHASES.FINDINGS_DECISION,
-    ],
+    from: [WORKFLOW_PHASES.DRAFTING_SPEC],
     to: WORKFLOW_PHASES.READY_FOR_BUILDER,
   },
   [WORKFLOW_EVENTS.RUN_BUILDER]: {
     from: [WORKFLOW_PHASES.READY_FOR_BUILDER],
     to: WORKFLOW_PHASES.BUILDER_RUNNING,
   },
-  [WORKFLOW_EVENTS.OPEN_ESCALATION]: {
+  [WORKFLOW_EVENTS.BUILDER_OPEN_ESCALATIONS]: {
     from: [WORKFLOW_PHASES.BUILDER_RUNNING],
-    to: WORKFLOW_PHASES.ESCALATION_DECISION,
+    to: WORKFLOW_PHASES.ESCALATION_DECISIONS,
   },
-  [WORKFLOW_EVENTS.RESOLVE_ESCALATION]: {
-    from: [WORKFLOW_PHASES.ESCALATION_DECISION],
+  [WORKFLOW_EVENTS.RESOLVE_ESCALATIONS]: {
+    from: [WORKFLOW_PHASES.ESCALATION_DECISIONS],
     to: WORKFLOW_PHASES.READY_FOR_BUILDER,
   },
+  [WORKFLOW_EVENTS.OWNER_REQUEST_SPEC_REVISION]: {
+    from: [
+      WORKFLOW_PHASES.ESCALATION_DECISIONS,
+      WORKFLOW_PHASES.FINDING_DECISIONS,
+    ],
+    to: WORKFLOW_PHASES.DRAFTING_SPEC,
+  },
   [WORKFLOW_EVENTS.BUILDER_DONE]: {
     from: [WORKFLOW_PHASES.BUILDER_RUNNING],
     to: WORKFLOW_PHASES.READY_FOR_VERIFIER,
@@ -48,18 +51,18 @@ export const WORKFLOW_TRANSITIONS: Record<WorkflowEvent, WorkflowTransition> = {
   },
   [WORKFLOW_EVENTS.VERIFIER_FOUND_FINDINGS]: {
     from: [WORKFLOW_PHASES.VERIFIER_RUNNING],
-    to: WORKFLOW_PHASES.FINDINGS_DECISION,
+    to: WORKFLOW_PHASES.FINDING_DECISIONS,
   },
-  [WORKFLOW_EVENTS.VERIFIER_APPROVED]: {
+  [WORKFLOW_EVENTS.VERIFIER_DONE]: {
     from: [WORKFLOW_PHASES.VERIFIER_RUNNING],
     to: WORKFLOW_PHASES.CANDIDATE_READY,
   },
-  [WORKFLOW_EVENTS.REJECT_FINDINGS]: {
-    from: [WORKFLOW_PHASES.FINDINGS_DECISION],
+  [WORKFLOW_EVENTS.OWNER_REJECT_FINDINGS]: {
+    from: [WORKFLOW_PHASES.FINDING_DECISIONS],
     to: WORKFLOW_PHASES.CANDIDATE_READY,
   },
-  [WORKFLOW_EVENTS.REQUEST_FIXES]: {
-    from: [WORKFLOW_PHASES.FINDINGS_DECISION],
+  [WORKFLOW_EVENTS.OWNER_REQUEST_FIXES]: {
+    from: [WORKFLOW_PHASES.FINDING_DECISIONS],
     to: WORKFLOW_PHASES.READY_FOR_BUILDER,
   },
 };
@@ -74,22 +77,21 @@ export const transitionWorkflow = ({
   event,
 }: TransitionWorkflowInput): WorkflowState => {
   assertWorkflowState(state);
-  const current = state;
   const transition = WORKFLOW_TRANSITIONS[event];
 
   if (transition === undefined) {
     throw new Error(`Unknown workflow event: "${event}".`);
   }
 
-  if (!transition.from.includes(current.phase)) {
+  if (!transition.from.includes(state.phase)) {
     throw new Error(
-      `Workflow event "${event}" is not allowed from phase "${current.phase}".`,
+      `Workflow event "${event}" is not allowed from phase "${state.phase}".`,
     );
   }
 
   return {
-    version: current.version,
-    specId: current.specId,
+    version: state.version,
+    specId: state.specId,
     phase: transition.to,
   };
 };

package/src/workflow/utils/getAgentRole.ts

@@ -9,13 +9,13 @@ import { WORKFLOW_PHASES, type WorkflowState } from '#workflow/state/schema.ts';
 
 const BUILDER_PHASES: readonly WorkflowState['phase'][] = [
   WORKFLOW_PHASES.BUILDER_RUNNING,
-  WORKFLOW_PHASES.ESCALATION_DECISION,
+  WORKFLOW_PHASES.ESCALATION_DECISIONS,
   WORKFLOW_PHASES.READY_FOR_VERIFIER,
 ];
 
 const VERIFIER_PHASES: readonly WorkflowState['phase'][] = [
   WORKFLOW_PHASES.VERIFIER_RUNNING,
-  WORKFLOW_PHASES.FINDINGS_DECISION,
+  WORKFLOW_PHASES.FINDING_DECISIONS,
 ];
 
 export const getAgentRole = (

package/src/workflow/verifier/resolveFindings.ts

@@ -1,6 +1,6 @@
 /**
  * Objective: Record owner decisions for current verifier findings on the active handoff.
- * Used: When the owner resolves a findings-decision handoff.
+ * Used: When the owner resolves a finding-decisions handoff.
  */
 
 import { assertVerifierHandoff } from '#artifacts/verifier-handoff/assertVerifierHandoff.ts';
@@ -18,46 +18,42 @@ import { writeWorkflowState } from '#workflow/state/writeWorkflowState.ts';
 import { transitionWorkflow } from '#workflow/transitions.ts';
 import { getWorkflowEventByVerifierHandoff } from '#workflow/verifier/utils/getWorkflowEventByVerifierHandoff.ts';
 
-type FindingDecisionRejected = {
-  findingId: string;
-  decision: typeof FINDING_DECISIONS.REJECT;
-  reason: string;
-};
+type SavedFindingDecision = NonNullable<VerifierFinding['decision']>;
 
-type FindingDecisionApproved = {
+export type FindingDecision = SavedFindingDecision & {
   findingId: string;
-  decision: typeof FINDING_DECISIONS.FIX_CODE;
 };
 
-export type FindingDecision = FindingDecisionApproved | FindingDecisionRejected;
-
 export type ResolvedFindings = {
   findings: VerifierFinding[];
   state: WorkflowState;
   projectRoot: string;
 };
 
-type AssertDecisionsInput = {
+type ApplyFindingDecisionsInput = {
   decisions: FindingDecision[];
   findings: VerifierFinding[];
 };
 
-function assertDecisions({ decisions, findings }: AssertDecisionsInput): void {
+const applyFindingDecisions = ({
+  decisions,
+  findings,
+}: ApplyFindingDecisionsInput): VerifierFinding[] => {
   const expectedIds = new Set(findings.map(({ id }) => id));
-  const seenIds = new Set<string>();
+  const decisionsById = new Map<string, FindingDecision>();
 
   for (const decision of decisions) {
     if (!expectedIds.has(decision.findingId)) {
       throw new Error(`Unknown finding ID: "${decision.findingId}".`);
     }
 
-    if (seenIds.has(decision.findingId)) {
+    if (decisionsById.has(decision.findingId)) {
       throw new Error(
         `Duplicate decision for finding "${decision.findingId}".`,
       );
     }
 
-    seenIds.add(decision.findingId);
+    decisionsById.set(decision.findingId, decision);
 
     if (
       decision.decision === FINDING_DECISIONS.REJECT &&
@@ -69,12 +65,17 @@ function assertDecisions({ decisions, findings }: AssertDecisionsInput): void {
     }
   }
 
-  const missing = findings.find(({ id }) => !seenIds.has(id));
+  const missing = findings.find(({ id }) => !decisionsById.has(id));
 
   if (missing !== undefined) {
     throw new Error(`Missing decision for finding "${missing.id}".`);
   }
-}
+
+  return findings.map((finding) => ({
+    ...finding,
+    decision: getSavedFindingDecision(decisionsById.get(finding.id)),
+  }));
+};
 
 type FindingWorkflow = {
   state: WorkflowState;
@@ -98,9 +99,9 @@ const readFindingWorkflow = async ({
     );
   }
 
-  if (state.phase !== WORKFLOW_PHASES.FINDINGS_DECISION) {
+  if (state.phase !== WORKFLOW_PHASES.FINDING_DECISIONS) {
     throw new Error(
-      `Finding resolution requires findings-decision state, found "${state.phase}".`,
+      `Finding resolution requires finding-decisions state, found "${state.phase}".`,
     );
   }
 
@@ -124,51 +125,25 @@ const readFindingWorkflow = async ({
   return { state, handoff };
 };
 
-type BuildFindingWorkflowInput = {
-  workflow: FindingWorkflow;
-  decisions: FindingDecision[];
-};
-
-const buildFindingWorkflow = ({
-  workflow,
-  decisions,
-}: BuildFindingWorkflowInput): FindingWorkflow => {
-  const { state, handoff } = workflow;
-  assertDecisions({ decisions, findings: handoff.findings });
-
-  const decisionsById = new Map(
-    decisions.map((decision) => [decision.findingId, decision]),
-  );
-
-  const findings = handoff.findings.map((finding) => {
-    const decision = decisionsById.get(finding.id);
-
-    if (decision?.decision === FINDING_DECISIONS.REJECT) {
-      return {
-        ...finding,
-        decision: {
-          decision: FINDING_DECISIONS.REJECT,
-          reason: decision.reason.trim(),
-        },
-      };
-    }
-
-    return { ...finding, decision: { decision: FINDING_DECISIONS.FIX_CODE } };
-  });
-
-  const nextHandoff = { ...handoff, findings };
-
-  const nextState = transitionWorkflow({
-    state,
-    event: getWorkflowEventByVerifierHandoff(nextHandoff),
-  });
+const getSavedFindingDecision = (
+  decision: FindingDecision | undefined,
+): SavedFindingDecision => {
+  if (decision?.decision === FINDING_DECISIONS.REVISE_SPEC) {
+    return {
+      decision: FINDING_DECISIONS.REVISE_SPEC,
+      reason: decision.reason.trim(),
+      specChange: decision.specChange,
+    };
+  }
 
-  assertVerifierHandoff({
-    handoff: nextHandoff,
-    specId: state.specId,
-  });
+  if (decision?.decision === FINDING_DECISIONS.REJECT) {
+    return {
+      decision: FINDING_DECISIONS.REJECT,
+      reason: decision.reason.trim(),
+    };
+  }
 
-  return { state: nextState, handoff: nextHandoff };
+  return { decision: FINDING_DECISIONS.FIX_CODE };
 };
 
 type ResolveFindingsInput = {
@@ -182,23 +157,35 @@ export const resolveFindings = async ({
   specId,
   decisions,
 }: ResolveFindingsInput): Promise<ResolvedFindings> => {
-  const currentWorkflow = await readFindingWorkflow({ paths, specId });
+  const { state, handoff } = await readFindingWorkflow({ paths, specId });
 
-  const workflow = buildFindingWorkflow({
-    workflow: currentWorkflow,
+  const findings = applyFindingDecisions({
     decisions,
+    findings: handoff.findings,
+  });
+
+  const nextHandoff = { ...handoff, findings };
+
+  const nextState = transitionWorkflow({
+    state,
+    event: getWorkflowEventByVerifierHandoff(nextHandoff),
+  });
+
+  assertVerifierHandoff({
+    handoff: nextHandoff,
+    specId: state.specId,
   });
 
   const handoffPath = await paths.getActiveVerifierHandoffPath(specId);
-  await writeJson({ path: handoffPath, data: workflow.handoff });
+  await writeJson({ path: handoffPath, data: nextHandoff });
   await writeWorkflowState({
     path: paths.getWorkflowPath(specId),
-    state: workflow.state,
+    state: nextState,
   });
 
   return {
-    findings: workflow.handoff.findings,
-    state: workflow.state,
+    findings,
+    state: nextState,
     projectRoot: paths.getProjectRoot(),
   };
 };

package/src/workflow/verifier/utils/getWorkflowEventByVerifierHandoff.ts

@@ -13,19 +13,27 @@ export const getWorkflowEventByVerifierHandoff = (
   handoff: VerifierHandoff,
 ): WorkflowEvent => {
   if (handoff.findings.length === 0) {
-    return WORKFLOW_EVENTS.VERIFIER_APPROVED;
+    return WORKFLOW_EVENTS.VERIFIER_DONE;
   }
 
   if (handoff.findings.every(({ decision }) => decision === null)) {
     return WORKFLOW_EVENTS.VERIFIER_FOUND_FINDINGS;
   }
 
+  if (
+    handoff.findings.some(
+      ({ decision }) => decision?.decision === FINDING_DECISIONS.REVISE_SPEC,
+    )
+  ) {
+    return WORKFLOW_EVENTS.OWNER_REQUEST_SPEC_REVISION;
+  }
+
   if (
     handoff.findings.some(
       ({ decision }) => decision?.decision === FINDING_DECISIONS.FIX_CODE,
     )
   ) {
-    return WORKFLOW_EVENTS.REQUEST_FIXES;
+    return WORKFLOW_EVENTS.OWNER_REQUEST_FIXES;
   }
 
   if (
@@ -33,7 +41,7 @@ export const getWorkflowEventByVerifierHandoff = (
       ({ decision }) => decision?.decision === FINDING_DECISIONS.REJECT,
     )
   ) {
-    return WORKFLOW_EVENTS.REJECT_FINDINGS;
+    return WORKFLOW_EVENTS.OWNER_REJECT_FINDINGS;
   }
 
   throw new Error('Unexpected verifier finding decisions.');