@emiliosp/pi-maestro 0.10.0 → 0.11.0

package/src/specs/create.ts

@@ -7,8 +7,6 @@ import { mkdir, writeFile } from 'node:fs/promises';
 import { createSpecId } from '#ids/createSpecId.ts';
 import type { MaestroPaths } from '#MaestroPaths.ts';
 import { loadSpecTemplate, renderSpecTemplate } from '#specs/template.ts';
-import { isErrnoException } from '#utils/is-errno-exception.ts';
-import { pathExists } from '#utils/path-exists.ts';
 import {
   assertWorkflowState,
   WORKFLOW_PHASES,
@@ -49,10 +47,6 @@ export const createSpec = async ({
   const workflowPath = paths.getWorkflowPath(specId);
   const prototypesPath = paths.getPrototypesPath(specId);
 
-  if (await pathExists(specPath)) {
-    throw new Error(`Spec directory already exists: ${specPath}.`);
-  }
-
   const template = await loadSpecTemplate();
   const spec = renderSpecTemplate({ template, specId, title });
 
@@ -63,12 +57,11 @@ export const createSpec = async ({
   } as const;
 
   assertWorkflowState(state);
-  let created = false;
+
+  await mkdir(paths.getSpecDirectory(), { recursive: true });
+  await mkdir(specPath);
 
   try {
-    await mkdir(paths.getSpecDirectory(), { recursive: true });
-    await mkdir(specPath);
-    created = true;
     await mkdir(prototypesPath, { recursive: true });
     await writeFile(specFilePath, spec, { encoding: 'utf8', flag: 'wx' });
     await writeWorkflowState({
@@ -76,20 +69,10 @@ export const createSpec = async ({
       state,
     });
   } catch (error) {
-    if (!created && isErrnoException(error) && error.code === 'EEXIST') {
-      throw new Error(`Spec directory already exists: ${specPath}.`, {
-        cause: error,
-      });
-    }
-
-    if (created) {
-      throw new Error(
-        `Spec creation failed after creating ${specPath}. Remove this directory before retrying.`,
-        { cause: error },
-      );
-    }
-
-    throw error;
+    throw new Error(
+      `Spec creation failed after creating ${specPath}. Remove this directory before retrying.`,
+      { cause: error },
+    );
   }
 
   return {

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

@@ -0,0 +1,73 @@
+/**
+ * Objective: Register the simplifier's fixed result recording tool.
+ * Used: When a child simplifier completes its refactoring pass.
+ */
+
+import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
+import { type Static, Type } from 'typebox';
+import { Value } from 'typebox/value';
+import {
+  SIMPLIFIER_HANDOFF_VERSION,
+  SimplifierSubmissionFields,
+} from '#artifacts/simplifier-handoff/schema.ts';
+import { resolveWorkflowContext } from '#tools/child/utils/resolveWorkflowContext.ts';
+import { completeSimplifierPass } from '#workflow/simplifier/completeSimplifierPass.ts';
+
+export const SIMPLIFIER_HANDOFF_TOOL = {
+  NAME: 'maestro_record_simplifier_handoff',
+  LABEL: 'Record Simplifier Handoff',
+  DESCRIPTION:
+    'Save the simplifier result at handoffs/simplifier/S.json and complete the workflow. Stop after success.',
+} as const;
+
+const SimplifierHandoffToolParameters = Type.Object(
+  SimplifierSubmissionFields,
+  { additionalProperties: false },
+);
+
+function assertSimplifierSubmission(
+  input: unknown,
+): asserts input is Static<typeof SimplifierHandoffToolParameters> {
+  const [error] = Value.Errors(SimplifierHandoffToolParameters, input);
+
+  if (error !== undefined) {
+    throw new Error(`Invalid simplifier submission: ${error.message}.`);
+  }
+}
+
+export const registerRecordSimplifierHandoffTool = (pi: ExtensionAPI): void => {
+  pi.registerTool({
+    name: SIMPLIFIER_HANDOFF_TOOL.NAME,
+    label: SIMPLIFIER_HANDOFF_TOOL.LABEL,
+    description: SIMPLIFIER_HANDOFF_TOOL.DESCRIPTION,
+    parameters: SimplifierHandoffToolParameters,
+    async execute(_toolCallId, params, _signal, _onUpdate, context) {
+      assertSimplifierSubmission(params);
+
+      const { paths } = await resolveWorkflowContext({
+        cwd: context.cwd,
+        specId: params.specId,
+      });
+
+      const completed = await completeSimplifierPass({
+        paths,
+        specId: params.specId,
+        handoff: { ...params, version: SIMPLIFIER_HANDOFF_VERSION },
+      });
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: 'Simplifier handoff and candidate-ready phase saved. Stop now.',
+          },
+        ],
+        details: {
+          specId: params.specId,
+          handoffPath: completed.handoffPath,
+          phase: completed.state.phase,
+        },
+      };
+    },
+  });
+};

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

@@ -83,20 +83,21 @@ const formatFindingIds = (findingIds: string[]): string =>
 const formatResolution = (details: FindingResolutionDetails): string => {
   const rejected = formatFindingIds(details.rejectedFindingIds);
   const requiringFix = formatFindingIds(details.findingsRequiringFixIds);
+  const summary = `Recorded rejections for ${rejected}. Findings requiring code fixes: ${requiringFix}.`;
 
   if (details.phase === WORKFLOW_PHASES.DRAFTING_SPEC) {
     const requiringRevision = formatFindingIds(
       details.findingsRequiringSpecRevisionIds,
     );
 
-    return `Recorded rejections for ${rejected}. Findings requiring code fixes: ${requiringFix}. Findings requiring spec revision: ${requiringRevision}. The workflow is drafting-spec. Revise the same spec with the owner and obtain renewed GREEN FLAG. Then call maestro_mark_spec_ready separately before running the builder.`;
+    return `${summary} Findings requiring spec revision: ${requiringRevision}. The workflow is drafting-spec. Revise the same spec with the owner and obtain renewed GREEN FLAG. Then call maestro_mark_spec_ready separately before running the builder.`;
   }
 
   if (details.phase === WORKFLOW_PHASES.READY_FOR_BUILDER) {
-    return `Recorded rejections for ${rejected}. Findings requiring code fixes: ${requiringFix}. The workflow is ready-for-builder. Run the builder separately.`;
+    return `${summary} The workflow is ready-for-builder. Run the builder separately.`;
   }
 
-  return `Recorded rejections for ${rejected}. Findings requiring code fixes: ${requiringFix}. The workflow is candidate-ready.`;
+  return `${summary} The workflow is simplifier-running. Call maestro_run_simplifier next with this specId, without another approval or verifier pass.`;
 };
 
 export const registerResolveFindingsTool = (pi: ExtensionAPI): void => {

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

@@ -74,7 +74,7 @@ const readBuilderResult = async ({
       );
     }
 
-    return await buildRunResult({ paths, specId, state });
+    return await readTerminalBuilderResult({ paths, specId, state });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
 
@@ -82,73 +82,63 @@ const readBuilderResult = async ({
   }
 };
 
-const readDoneBuilderResult = async ({
-  paths,
-  specId,
-}: ReadBuilderResultInput): Promise<BuilderRunResult> => {
-  const handoff = await readBuilderHandoff({
-    path: await paths.getActiveBuilderHandoffPath(specId),
-    specId,
-  });
-
-  if (handoff.status !== BUILDER_HANDOFF_STATUSES.DONE) {
-    throw new Error(
-      `Builder handoff status does not match workflow phase "${WORKFLOW_PHASES.READY_FOR_VERIFIER}".`,
-    );
-  }
-
-  return {
-    outcome: BUILDER_HANDOFF_STATUSES.DONE,
-    specId,
-    phase: WORKFLOW_PHASES.READY_FOR_VERIFIER,
-    handoff,
-  };
-};
-
-type BuildRunResultInput = {
+type ReadTerminalBuilderResultInput = {
   paths: MaestroPaths;
   specId: string;
   state: WorkflowState;
 };
 
-const buildRunResult = async ({
+const readTerminalBuilderResult = async ({
   paths,
   specId,
   state,
-}: BuildRunResultInput): Promise<BuilderRunResult> => {
-  if (state.phase === WORKFLOW_PHASES.READY_FOR_VERIFIER) {
-    return await readDoneBuilderResult({ paths, specId });
+}: ReadTerminalBuilderResultInput): Promise<BuilderRunResult> => {
+  if (
+    state.phase !== WORKFLOW_PHASES.READY_FOR_VERIFIER &&
+    state.phase !== WORKFLOW_PHASES.ESCALATION_DECISIONS
+  ) {
+    throw new Error(
+      `Builder returned with unexpected workflow phase "${state.phase}".`,
+    );
   }
 
-  if (state.phase === WORKFLOW_PHASES.ESCALATION_DECISIONS) {
-    const handoff = await readBuilderHandoff({
-      path: await paths.getActiveBuilderHandoffPath(specId),
-      specId,
-    });
+  const handoff = await readBuilderHandoff({
+    path: await paths.getActiveBuilderHandoffPath(specId),
+    specId,
+  });
 
-    if (handoff.status !== BUILDER_HANDOFF_STATUSES.ESCALATION) {
-      throw new Error(
-        `Builder handoff status does not match workflow phase "${state.phase}".`,
-      );
-    }
+  const expectedStatus =
+    state.phase === WORKFLOW_PHASES.READY_FOR_VERIFIER
+      ? BUILDER_HANDOFF_STATUSES.DONE
+      : BUILDER_HANDOFF_STATUSES.ESCALATION;
 
-    if (handoff.escalations.some(({ resolution }) => resolution !== null)) {
-      throw new Error(
-        'Current builder escalations already contain an owner resolution.',
-      );
-    }
+  if (handoff.status !== expectedStatus) {
+    throw new Error(
+      `Builder handoff status does not match workflow phase "${state.phase}".`,
+    );
+  }
 
+  if (state.phase === WORKFLOW_PHASES.READY_FOR_VERIFIER) {
     return {
-      outcome: BUILDER_HANDOFF_STATUSES.ESCALATION,
+      outcome: BUILDER_HANDOFF_STATUSES.DONE,
       specId,
       phase: state.phase,
       handoff,
     };
   }
 
-  throw new Error(
-    `Builder returned with unexpected workflow phase "${state.phase}".`,
-  );
+  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,
+    handoff,
+  };
 };
 
 const formatBuilderResult = (result: BuilderRunResult): string => {

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

@@ -0,0 +1,182 @@
+/**
+ * Objective: Run the simplifier in Git projects or explicitly skip unavailable Git.
+ * Used: After verification succeeds or the owner rejects all findings.
+ */
+
+import { randomUUID } from 'node:crypto';
+import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
+import type { SubagentDelegationRequest } from 'pi-subagents/delegation';
+import { Type } from 'typebox';
+import { readSimplifierHandoff } from '#artifacts/simplifier-handoff/readSimplifierHandoff.ts';
+import { AGENTS } from '#config/schema.ts';
+import { SPEC_ID_PATTERN } from '#ids/isValidSpecId.ts';
+import type { MaestroPaths } from '#MaestroPaths.ts';
+import { refreshMaestroStatus } from '#maestro/status/refreshMaestroStatus.ts';
+import {
+  assertDelegationResponse,
+  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_EVENTS, WORKFLOW_PHASES } from '#workflow/state/schema.ts';
+import { writeWorkflowState } from '#workflow/state/writeWorkflowState.ts';
+import { transitionWorkflow } from '#workflow/transitions.ts';
+
+export const RUN_SIMPLIFIER_TOOL = {
+  NAME: 'maestro_run_simplifier',
+  LABEL: 'Run Simplifier',
+  DESCRIPTION:
+    'Run the simplifier in the foreground from simplifier-running. If Git readiness cannot be confirmed, warn and complete without delegation.',
+} as const;
+
+const RunSimplifierToolParameters = Type.Object(
+  { specId: Type.String({ pattern: SPEC_ID_PATTERN.source }) },
+  { additionalProperties: false },
+);
+
+const MILLISECONDS_PER_MINUTE = 60_000;
+
+const GIT_SKIP_WARNING = 'Simplifier skipped: Git repository unavailable.';
+
+type GitReadinessInput = {
+  pi: ExtensionAPI;
+  projectRoot: string;
+};
+
+const isGitReady = async ({
+  pi,
+  projectRoot,
+}: GitReadinessInput): Promise<boolean> => {
+  try {
+    const result = await pi.exec(
+      'git',
+      ['rev-parse', '--is-inside-work-tree'],
+      { cwd: projectRoot },
+    );
+
+    return result.code === 0 && result.stdout.trim() === 'true';
+  } catch {
+    return false;
+  }
+};
+
+type ReadSimplifierResultInput = {
+  paths: MaestroPaths;
+  specId: string;
+};
+
+const readSimplifierResult = async ({
+  paths,
+  specId,
+}: ReadSimplifierResultInput) => {
+  try {
+    const state = await readWorkflowState(paths.getWorkflowPath(specId));
+
+    if (state.specId !== specId) {
+      throw new Error(
+        `Workflow spec ID mismatch: expected "${specId}", found "${state.specId}".`,
+      );
+    }
+
+    if (state.phase !== WORKFLOW_PHASES.CANDIDATE_READY) {
+      throw new Error(
+        `The simplifier returned without recording a valid terminal handoff. Workflow phase is "${state.phase}".`,
+      );
+    }
+
+    const handoff = await readSimplifierHandoff({
+      path: paths.getSimplifierHandoffPath(specId),
+      specId,
+      projectRoot: paths.getProjectRoot(),
+    });
+
+    return { specId, phase: state.phase, outcome: state.phase, handoff };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Simplifier protocol error: ${message}`, { cause: error });
+  }
+};
+
+export const registerRunSimplifierTool = (pi: ExtensionAPI): void => {
+  pi.registerTool({
+    name: RUN_SIMPLIFIER_TOOL.NAME,
+    label: RUN_SIMPLIFIER_TOOL.LABEL,
+    description: RUN_SIMPLIFIER_TOOL.DESCRIPTION,
+    parameters: RunSimplifierToolParameters,
+    async execute(toolCallId, { specId }, _signal, _onUpdate, context) {
+      const { paths, config, projectRoot } = await resolveToolRunContext(
+        context.cwd,
+      );
+
+      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 run requires simplifier-running state, found "${state.phase}".`,
+        );
+      }
+
+      await refreshMaestroStatus(context);
+
+      if (!(await isGitReady({ pi, projectRoot }))) {
+        const nextState = transitionWorkflow({
+          state,
+          event: WORKFLOW_EVENTS.SIMPLIFIER_SKIPPED,
+        });
+
+        await writeWorkflowState({ path: workflowPath, state: nextState });
+        context.ui.notify(GIT_SKIP_WARNING, 'warning');
+
+        return {
+          content: [{ type: 'text', text: GIT_SKIP_WARNING }],
+          details: {
+            specId,
+            phase: nextState.phase,
+            skipped: true,
+            warning: GIT_SKIP_WARNING,
+          },
+        };
+      }
+
+      const request: SubagentDelegationRequest = {
+        requestId: randomUUID(),
+        ownerRunId: toolCallId,
+        nodeId: WORKFLOW_ROLES.SIMPLIFIER,
+        agent: AGENTS.SIMPLIFIER,
+        task: `Simplify accepted code for specId "${specId}" in the project directory "${projectRoot}". Discover all current staged, unstaged, and untracked code changes with Git, including pre-existing changes.`,
+        context: 'fresh',
+        cwd: projectRoot,
+        model: config.simplifier.model,
+        thinking: config.simplifier.thinking,
+        timeoutMs: config.simplifier.timeoutMinutes * MILLISECONDS_PER_MINUTE,
+        result: { kind: 'text' },
+      };
+
+      const response = await waitForDelegationResponse({
+        piEventsBus: pi.events,
+        request,
+      });
+
+      assertDelegationResponse(response);
+      const result = await readSimplifierResult({ paths, specId });
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `Simplifier completed spec ${specId}. The workflow is candidate-ready. Report the saved simplifier summary and notes as its report, not verifier evidence.`,
+          },
+        ],
+        details: result,
+      };
+    },
+  });
+};

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.SIMPLIFIER_RUNNING
+  | typeof WORKFLOW_PHASES.FINDING_DECISIONS;
 
-type FindingsResult = {
-  outcome: typeof WORKFLOW_PHASES.FINDING_DECISIONS;
+type VerifierRunResult = {
+  outcome: VerifierTerminalPhase;
   specId: string;
-  phase: typeof WORKFLOW_PHASES.FINDING_DECISIONS;
+  phase: VerifierTerminalPhase;
   handoff: VerifierHandoff;
 };
 
-type VerifierRunResult = CandidateReadyResult | FindingsResult;
-
 type ReadTerminalVerifierResultInput = {
   paths: MaestroPaths;
   specId: string;
@@ -65,11 +60,9 @@ const readTerminalVerifierResult = async ({
   paths,
   specId,
   state,
-}: ReadTerminalVerifierResultInput): Promise<
-  CandidateReadyResult | FindingsResult
-> => {
+}: 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(
@@ -85,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(
@@ -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 = {
@@ -142,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/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

@@ -6,6 +6,7 @@
 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';
@@ -20,6 +21,45 @@ export type EscalationDecision = EscalationResolution & {
   escalationId: string;
 };
 
+type ApplyEscalationDecisionsInput = {
+  escalations: Escalation[];
+  decisions: EscalationDecision[];
+};
+
+const applyEscalationDecisions = ({
+  escalations,
+  decisions,
+}: 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(escalations.map(({ id }) => id));
+  const resolutions = new Map<string, EscalationResolution>();
+
+  for (const { escalationId, ...resolution } of decisions) {
+    if (!expectedIds.has(escalationId))
+      throw new Error(`Unknown escalation ID: "${escalationId}".`);
+
+    if (resolutions.has(escalationId))
+      throw new Error(`Duplicate decision for escalation "${escalationId}".`);
+
+    resolutions.set(escalationId, resolution);
+  }
+
+  return escalations.map((escalation) => {
+    const resolution = resolutions.get(escalation.id);
+
+    if (resolution === undefined)
+      throw new Error(`Missing decision for escalation "${escalation.id}".`);
+
+    return { ...escalation, resolution };
+  });
+};
+
 type ResolveEscalationsInput = {
   paths: MaestroPaths;
   specId: string;
@@ -51,33 +91,9 @@ export const resolveEscalations = async ({
     throw new Error('Escalation resolution requires an escalation handoff.');
   }
 
-  if (handoff.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 resolutions = new Map<string, EscalationResolution>();
-
-  for (const { escalationId, ...resolution } of decisions) {
-    if (!expectedIds.has(escalationId))
-      throw new Error(`Unknown escalation ID: "${escalationId}".`);
-
-    if (resolutions.has(escalationId))
-      throw new Error(`Duplicate decision for escalation "${escalationId}".`);
-
-    resolutions.set(escalationId, resolution);
-  }
-
-  const escalations = handoff.escalations.map((escalation) => {
-    const resolution = resolutions.get(escalation.id);
-
-    if (resolution === undefined)
-      throw new Error(`Missing decision for escalation "${escalation.id}".`);
-
-    return { ...escalation, resolution };
+  const escalations = applyEscalationDecisions({
+    escalations: handoff.escalations,
+    decisions,
   });
 
   const nextHandoff = { ...handoff, escalations };

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];