@emiliosp/pi-maestro 0.5.2 → 0.6.0

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

@@ -6,19 +6,17 @@
 import { StringEnum } from '@earendil-works/pi-ai';
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
 import { Type } from 'typebox';
+import { FINDING_DECISIONS } from '#artifacts/verifier-handoff/schema.ts';
 import { SPEC_ID_PATTERN } from '#ids/isValidSpecId.ts';
 import { resolveToolRunContext } from '#tools/utils/resolveToolRunContext.ts';
-import {
-  FINDING_DECISIONS,
-  resolveFindings,
-} from '#workflow/findings/resolveFindings.ts';
+import { resolveFindings } from '#workflow/findings/resolveFindings.ts';
 import { WORKFLOW_PHASES } from '#workflow/state/schema.ts';
 
 export const RESOLVE_FINDINGS_TOOL = {
   NAME: 'maestro_resolve_findings',
   LABEL: 'Resolve Findings',
   DESCRIPTION:
-    'Record the explicit owner decision for every current verifier finding when the approved contract remains valid. Commit the resolution and workflow transition on the current branch. If the contract must change, edit spec.md and use maestro_mark_spec_ready instead.',
+    'Record the explicit owner decision for every current verifier finding when the approved contract remains valid. Save the resolution and workflow transition. If the contract must change, edit spec.md and use maestro_mark_spec_ready instead.',
 } as const;
 
 const FindingDecisionFields = {
@@ -31,7 +29,9 @@ const RejectFindingDecisionSchema = Type.Object(
     decision: StringEnum([FINDING_DECISIONS.REJECT] as const),
     reason: Type.String({ minLength: 1 }),
   },
-  { additionalProperties: false },
+  {
+    additionalProperties: false,
+  },
 );
 
 const FixCodeFindingDecisionSchema = Type.Object(
@@ -39,7 +39,9 @@ const FixCodeFindingDecisionSchema = Type.Object(
     ...FindingDecisionFields,
     decision: StringEnum([FINDING_DECISIONS.FIX_CODE] as const),
   },
-  { additionalProperties: false },
+  {
+    additionalProperties: false,
+  },
 );
 
 const FindingDecisionSchema = Type.Union([
@@ -57,10 +59,8 @@ const ResolveFindingsToolParameters = Type.Object(
 
 type FindingResolutionDetails = {
   specId: string;
-  revision: number;
   phase: string;
-  repositoryRoot: string;
-  checkpointCommit: string;
+  projectRoot: string;
   rejectedFindingIds: string[];
   findingsRequiringFixIds: string[];
 };
@@ -102,15 +102,17 @@ export const registerResolveFindingsTool = (pi: ExtensionAPI): void => {
 
       const details: FindingResolutionDetails = {
         specId: resolved.state.specId,
-        revision: resolved.state.revision,
         phase: resolved.state.phase,
-        repositoryRoot: resolved.repositoryRoot,
-        checkpointCommit: resolved.checkpointCommit,
+        projectRoot: resolved.projectRoot,
         rejectedFindingIds: resolved.findings
-          .filter(({ rejection }) => rejection !== null)
+          .filter(
+            ({ decision }) => decision?.decision === FINDING_DECISIONS.REJECT,
+          )
           .map(({ id }) => id),
         findingsRequiringFixIds: resolved.findings
-          .filter(({ rejection }) => rejection === null)
+          .filter(
+            ({ decision }) => decision?.decision === FINDING_DECISIONS.FIX_CODE,
+          )
           .map(({ id }) => id),
       };
 

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

@@ -15,7 +15,6 @@ import {
 import { readEscalationHistory } from '#artifacts/escalation/readEscalationHistory.ts';
 import type { Escalation } from '#artifacts/escalation/schema.ts';
 import { AGENTS } from '#config/schema.ts';
-import { getRepositoryStatus } from '#git/repository/getRepositoryStatus.ts';
 import { SPEC_ID_PATTERN } from '#ids/isValidSpecId.ts';
 import type { MaestroPaths } from '#MaestroPaths.ts';
 import { refreshMaestroStatus } from '#maestro/status/refreshMaestroStatus.ts';
@@ -33,7 +32,7 @@ export const RUN_BUILDER_TOOL = {
   NAME: 'maestro_run_builder',
   LABEL: 'Run Builder',
   DESCRIPTION:
-    'Run the builder in the current checkout for an owner-approved spec. The builder runs in the foreground and cannot be retried after a committed failure.',
+    'Run the builder in the project directory for an owner-approved spec. The builder runs in the foreground and cannot be retried after a recorded failure.',
 } as const;
 
 const RunBuilderToolParameters = Type.Object(
@@ -49,45 +48,32 @@ type BuilderRunResult =
   | {
       outcome: typeof BUILDER_HANDOFF_STATUSES.DONE;
       specId: string;
-      revision: number;
       phase: typeof WORKFLOW_PHASES.READY_FOR_VERIFIER;
       handoff: BuilderHandoff;
     }
   | {
       outcome: typeof BUILDER_HANDOFF_STATUSES.FAILED;
       specId: string;
-      revision: number;
       phase: typeof WORKFLOW_PHASES.BUILDER_FAILED;
       handoff: BuilderHandoff;
     }
   | {
       outcome: typeof BUILDER_HANDOFF_STATUSES.ESCALATION;
       specId: string;
-      revision: number;
       phase: typeof WORKFLOW_PHASES.ESCALATION_DECISION;
       escalation: Escalation;
     };
 
-type ReadCommittedBuilderResultInput = {
+type ReadBuilderResultInput = {
   paths: MaestroPaths;
   specId: string;
 };
 
-const readCommittedBuilderResult = async ({
+const readBuilderResult = async ({
   paths,
   specId,
-}: ReadCommittedBuilderResultInput): Promise<BuilderRunResult> => {
+}: ReadBuilderResultInput): Promise<BuilderRunResult> => {
   try {
-    const repositoryStatus = await getRepositoryStatus(
-      paths.getRepositoryRoot(),
-    );
-
-    if (!repositoryStatus.clean) {
-      throw new Error(
-        'The builder returned without committing its final artifact and current work.',
-      );
-    }
-
     const state = await readWorkflowState(paths.getWorkflowPath(specId));
 
     if (state.specId !== specId) {
@@ -107,7 +93,6 @@ const readCommittedBuilderResult = async ({
 type ReadTerminalBuilderResultInput = {
   paths: MaestroPaths;
   specId: string;
-  revision: number;
   phase:
     | typeof WORKFLOW_PHASES.READY_FOR_VERIFIER
     | typeof WORKFLOW_PHASES.BUILDER_FAILED;
@@ -116,13 +101,11 @@ type ReadTerminalBuilderResultInput = {
 const readTerminalBuilderResult = async ({
   paths,
   specId,
-  revision,
   phase,
 }: ReadTerminalBuilderResultInput): Promise<BuilderRunResult> => {
   const handoff = await readBuilderHandoff({
-    path: paths.getBuilderHandoffPath(specId),
+    path: await paths.getActiveBuilderHandoffPath(specId),
     specId,
-    revision,
   });
 
   const expectedStatus =
@@ -140,7 +123,6 @@ const readTerminalBuilderResult = async ({
     return {
       outcome: BUILDER_HANDOFF_STATUSES.DONE,
       specId,
-      revision,
       phase,
       handoff,
     };
@@ -149,7 +131,6 @@ const readTerminalBuilderResult = async ({
   return {
     outcome: BUILDER_HANDOFF_STATUSES.FAILED,
     specId,
-    revision,
     phase,
     handoff,
   };
@@ -173,7 +154,6 @@ const buildRunResult = async ({
     return await readTerminalBuilderResult({
       paths,
       specId,
-      revision: state.revision,
       phase: state.phase,
     });
   }
@@ -182,25 +162,17 @@ const buildRunResult = async ({
     const history = await readEscalationHistory({
       directory: paths.getEscalationsPath(specId),
       specId,
-      currentRevision: state.revision,
     });
 
     const escalation = history.at(-1);
 
-    if (
-      escalation === undefined ||
-      escalation.revision !== state.revision ||
-      escalation.resolution !== null
-    ) {
-      throw new Error(
-        'The builder escalation is missing, stale, or already resolved.',
-      );
+    if (escalation === undefined || escalation.resolution !== null) {
+      throw new Error('The builder escalation is missing or already resolved.');
     }
 
     return {
       outcome: BUILDER_HANDOFF_STATUSES.ESCALATION,
       specId,
-      revision: state.revision,
       phase: state.phase,
       escalation,
     };
@@ -242,9 +214,9 @@ 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 current checkout "${run.repositoryRoot}". Read all applicable AGENTS.md files before working.`,
+        task: `Implement specId "${specId}" in the project directory "${run.projectRoot}".`,
         context: 'fresh',
-        cwd: run.repositoryRoot,
+        cwd: run.projectRoot,
         model: config.builder.model,
         thinking: config.builder.thinking,
         timeoutMs: config.builder.timeoutMinutes * MILLISECONDS_PER_MINUTE,
@@ -257,7 +229,7 @@ export const registerRunBuilderTool = (pi: ExtensionAPI): void => {
       });
 
       assertDelegationResponse(response);
-      const result = await readCommittedBuilderResult({ paths, specId });
+      const result = await readBuilderResult({ paths, specId });
 
       return {
         content: [{ type: 'text', text: formatBuilderResult(result) }],

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

@@ -10,7 +10,6 @@ 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 { getRepositoryStatus } from '#git/repository/getRepositoryStatus.ts';
 import { SPEC_ID_PATTERN } from '#ids/isValidSpecId.ts';
 import type { MaestroPaths } from '#MaestroPaths.ts';
 import { refreshMaestroStatus } from '#maestro/status/refreshMaestroStatus.ts';
@@ -22,16 +21,13 @@ import { resolveToolRunContext } from '#tools/utils/resolveToolRunContext.ts';
 import { WORKFLOW_ROLES } from '#workflow/roles.ts';
 import { readWorkflowState } from '#workflow/state/readWorkflowState.ts';
 import { WORKFLOW_PHASES, type WorkflowState } from '#workflow/state/schema.ts';
-import {
-  prepareVerifierRun,
-  type VerifierRun,
-} from '#workflow/verifier/prepareVerifierRun.ts';
+import { prepareVerifierRun } from '#workflow/verifier/prepareVerifierRun.ts';
 
 export const RUN_VERIFIER_TOOL = {
   NAME: 'maestro_run_verifier',
   LABEL: 'Run Verifier',
   DESCRIPTION:
-    'Run the verifier in the current checkout for a completed builder candidate. The verifier runs in the foreground.',
+    'Run the verifier in the project directory for a completed builder candidate. The verifier runs in the foreground.',
 } as const;
 
 const RunVerifierToolParameters = Type.Object(
@@ -46,20 +42,14 @@ const MILLISECONDS_PER_MINUTE = 60_000;
 type CandidateReadyResult = {
   outcome: typeof WORKFLOW_PHASES.CANDIDATE_READY;
   specId: string;
-  revision: number;
   phase: typeof WORKFLOW_PHASES.CANDIDATE_READY;
-  candidateCommit: string;
-  checkpointCommit: string;
   handoff: VerifierHandoff;
 };
 
 type FindingsResult = {
   outcome: typeof WORKFLOW_PHASES.FINDINGS_DECISION;
   specId: string;
-  revision: number;
   phase: typeof WORKFLOW_PHASES.FINDINGS_DECISION;
-  candidateCommit: string;
-  checkpointCommit: string;
   handoff: VerifierHandoff;
 };
 
@@ -68,14 +58,12 @@ type VerifierRunResult = CandidateReadyResult | FindingsResult;
 type ReadTerminalVerifierResultInput = {
   paths: MaestroPaths;
   specId: string;
-  run: VerifierRun;
   state: WorkflowState;
 };
 
 const readTerminalVerifierResult = async ({
   paths,
   specId,
-  run,
   state,
 }: ReadTerminalVerifierResultInput): Promise<
   CandidateReadyResult | FindingsResult
@@ -89,18 +77,9 @@ const readTerminalVerifierResult = async ({
     );
   }
 
-  const repositoryStatus = await getRepositoryStatus(run.repositoryRoot);
-
-  if (!repositoryStatus.clean) {
-    throw new Error(
-      'The verifier returned without committing its final handoff.',
-    );
-  }
-
   const handoff = await readVerifierHandoff({
-    path: paths.getVerifierHandoffPath(specId),
+    path: await paths.getActiveVerifierHandoffPath(specId),
     specId,
-    revision: state.revision,
   });
 
   const expectedPhase =
@@ -116,9 +95,6 @@ const readTerminalVerifierResult = async ({
 
   const details = {
     specId,
-    revision: state.revision,
-    candidateCommit: run.candidateCommit,
-    checkpointCommit: run.checkpointCommit,
     handoff,
   };
 
@@ -132,13 +108,11 @@ const readTerminalVerifierResult = async ({
 type ReadVerifierResultInput = {
   paths: MaestroPaths;
   specId: string;
-  run: VerifierRun;
 };
 
 const readVerifierResult = async ({
   paths,
   specId,
-  run,
 }: ReadVerifierResultInput): Promise<VerifierRunResult> => {
   try {
     const state = await readWorkflowState(paths.getWorkflowPath(specId));
@@ -158,7 +132,6 @@ const readVerifierResult = async ({
     return await readTerminalVerifierResult({
       paths,
       specId,
-      run,
       state,
     });
   } catch (error) {
@@ -194,9 +167,9 @@ export const registerRunVerifierTool = (pi: ExtensionAPI): void => {
         nodeId: WORKFLOW_ROLES.VERIFIER,
         // pi-subagents loads this name from agents/verifier.md through package.json.
         agent: AGENTS.VERIFIER,
-        task: `Verify specId "${specId}" at candidate checkpoint "${run.candidateCommit}" in the current checkout "${run.repositoryRoot}". Read all applicable AGENTS.md files before working.`,
+        task: `Verify specId "${specId}" in the live project directory "${run.projectRoot}"`,
         context: 'fresh',
-        cwd: run.repositoryRoot,
+        cwd: run.projectRoot,
         model: config.verifier.model,
         thinking: config.verifier.thinking,
         timeoutMs: config.verifier.timeoutMinutes * MILLISECONDS_PER_MINUTE,
@@ -209,7 +182,7 @@ export const registerRunVerifierTool = (pi: ExtensionAPI): void => {
       });
 
       assertDelegationResponse(response);
-      const result = await readVerifierResult({ paths, specId, run });
+      const result = await readVerifierResult({ paths, specId });
 
       return {
         content: [{ type: 'text', text: formatVerifierResult(result) }],

package/src/tools/utils/resolveToolRunContext.ts

@@ -1,15 +1,15 @@
 /**
- * Objective: Resolve the repository context shared by Pi tools.
- * Used: Whenever a Pi tool needs the current checkout, configuration, and paths.
+ * Objective: Resolve the project context shared by Pi tools.
+ * Used: Whenever a Pi tool needs the project directory, configuration, and paths.
  */
 
+import { realpath } from 'node:fs/promises';
 import { loadConfiguration } from '#config/loadConfiguration.ts';
 import type { MaestroConfig } from '#config/schema.ts';
-import { findRepositoryRoot } from '#git/repository/findRepositoryRoot.ts';
 import { MaestroPaths } from '#MaestroPaths.ts';
 
 export type ToolRunContext = {
-  repositoryRoot: string;
+  projectRoot: string;
   config: MaestroConfig;
   paths: MaestroPaths;
 };
@@ -17,12 +17,12 @@ export type ToolRunContext = {
 export const resolveToolRunContext = async (
   cwd: string,
 ): Promise<ToolRunContext> => {
-  const repositoryRoot = await findRepositoryRoot(cwd);
-  const config = await loadConfiguration(repositoryRoot);
+  const projectRoot = await realpath(cwd);
+  const config = await loadConfiguration(projectRoot);
 
   return {
-    repositoryRoot,
+    projectRoot,
     config,
-    paths: new MaestroPaths({ repositoryRoot, config }),
+    paths: new MaestroPaths({ projectRoot, config }),
   };
 };

package/src/utils/path-strictly-within.ts

@@ -8,12 +8,12 @@ import { isPathWithinOrEqual } from '#utils/path-within-or-equal.ts';
 
 type IsPathStrictlyWithinInput = {
   parent: string;
-  candidate: string;
+  path: string;
 };
 
 export const isPathStrictlyWithin = ({
   parent,
-  candidate,
+  path,
 }: IsPathStrictlyWithinInput): boolean =>
-  relative(parent, candidate) !== '' &&
-  isPathWithinOrEqual({ parent, candidate });
+  relative(parent, path) !== '' &&
+  isPathWithinOrEqual({ parent, candidate: path });

package/src/utils/write-json.ts

@@ -0,0 +1,24 @@
+/**
+ * Objective: Write formatted JSON to a file.
+ * Used: When Maestro writes workflow state and artifact JSON files.
+ */
+
+import { writeFile } from 'node:fs/promises';
+
+type WriteJsonInput = {
+  path: string;
+  data: unknown;
+};
+
+export const writeJson = async ({
+  path,
+  data,
+}: WriteJsonInput): Promise<void> => {
+  const content = JSON.stringify(data, null, 2);
+
+  if (content === undefined) {
+    throw new Error('JSON data must be serializable.');
+  }
+
+  await writeFile(path, `${content}\n`);
+};

package/src/workflow/builder/completeBuilderPass.ts

@@ -4,7 +4,6 @@
  */
 
 import { mkdir } from 'node:fs/promises';
-import { dirname } from 'node:path';
 import { assertBuilderHandoff } from '#artifacts/builder-handoff/assertBuilderHandoff.ts';
 import {
   BUILDER_HANDOFF_STATUSES,
@@ -14,7 +13,6 @@ import {
 } from '#artifacts/builder-handoff/schema.ts';
 import { writeBuilderHandoff } from '#artifacts/builder-handoff/writeBuilderHandoff.ts';
 import type { MaestroPaths } from '#MaestroPaths.ts';
-import { pathExists } from '#utils/path-exists.ts';
 import { readWorkflowState } from '#workflow/state/readWorkflowState.ts';
 import {
   WORKFLOW_EVENTS,
@@ -27,7 +25,8 @@ import { transitionWorkflow } from '#workflow/transitions.ts';
 export type CompletedBuilderPass = {
   handoff: BuilderHandoff;
   state: WorkflowState;
-  repositoryRoot: string;
+  projectRoot: string;
+  handoffPath: string;
 };
 
 type BuildBuilderHandoffInput = {
@@ -43,7 +42,6 @@ const buildBuilderHandoff = ({
     return {
       version: BUILDER_HANDOFF_VERSION,
       specId: state.specId,
-      revision: state.revision + 1,
       status: draftHandoff.status,
       summary: draftHandoff.summary,
       acceptanceCriteria: draftHandoff.acceptanceCriteria,
@@ -55,7 +53,6 @@ const buildBuilderHandoff = ({
   return {
     version: BUILDER_HANDOFF_VERSION,
     specId: state.specId,
-    revision: state.revision + 1,
     status: draftHandoff.status,
     summary: draftHandoff.summary,
     acceptanceCriteria: draftHandoff.acceptanceCriteria,
@@ -75,7 +72,6 @@ export const completeBuilderPass = async ({
   handoff: draftHandoff,
 }: CompleteBuilderPassInput): Promise<CompletedBuilderPass> => {
   const workflowPath = paths.getWorkflowPath(specId);
-  const handoffPath = paths.getBuilderHandoffPath(specId);
   const currentState = await readWorkflowState(workflowPath);
 
   if (currentState.specId !== specId) {
@@ -90,14 +86,9 @@ export const completeBuilderPass = async ({
     );
   }
 
-  if (await pathExists(handoffPath)) {
-    throw new Error('Builder terminal handoff already exists.');
-  }
-
   const handoffInput = {
     handoff: buildBuilderHandoff({ draftHandoff, state: currentState }),
     specId: currentState.specId,
-    revision: currentState.revision + 1,
   };
 
   assertBuilderHandoff(handoffInput);
@@ -111,24 +102,24 @@ export const completeBuilderPass = async ({
         : WORKFLOW_EVENTS.BUILDER_FAILED,
   });
 
-  await mkdir(dirname(handoffPath), { recursive: true });
+  await mkdir(paths.getBuilderHandoffsPath(specId), { recursive: true });
+  const handoffPath = await paths.getNextBuilderHandoffPath(specId);
 
   await writeBuilderHandoff({
     path: handoffPath,
     handoff,
     specId: currentState.specId,
-    revision: nextState.revision,
   });
 
   await writeWorkflowState({
     path: workflowPath,
     state: nextState,
-    currentRevision: currentState.revision,
   });
 
   return {
     handoff,
+    handoffPath,
     state: nextState,
-    repositoryRoot: paths.getRepositoryRoot(),
+    projectRoot: paths.getProjectRoot(),
   };
 };

package/src/workflow/builder/prepareBuilderRun.ts

@@ -1,11 +1,8 @@
 /**
- * Objective: Prepare a committed builder run checkpoint in the current checkout.
+ * Objective: Prepare a builder run transition in the project directory.
  * Used: Before Maestro runs a builder pass.
  */
 
-import { rm } from 'node:fs/promises';
-import { createWorkflowCheckpointCommit } from '#git/commits/createWorkflowCheckpointCommit.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';
@@ -16,9 +13,7 @@ import { transitionWorkflow } from '#workflow/transitions.ts';
 
 export type BuilderRun = {
   specId: string;
-  revision: number;
-  repositoryRoot: string;
-  checkpointCommit: string;
+  projectRoot: string;
 };
 
 type AssertBuilderRunBaseInput = {
@@ -42,12 +37,6 @@ async function assertBuilderRunBase({
     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 run requires a clean current checkout.');
-  }
-
   if (!(await pathExists(paths.getSpecFilePath(specId)))) {
     throw new Error(`Spec file is missing: ${paths.getSpecFilePath(specId)}.`);
   }
@@ -73,13 +62,7 @@ export const prepareBuilderRun = async ({
   await assertBuilderRunBase({ paths, specId });
 
   const workflowPath = paths.getWorkflowPath(specId);
-  const handoffPath = paths.getBuilderHandoffPath(specId);
   const currentState = await readWorkflowState(workflowPath);
-  const handoffExists = await pathExists(handoffPath);
-
-  if (handoffExists) {
-    await rm(handoffPath);
-  }
 
   const nextState = transitionWorkflow({
     state: currentState,
@@ -89,24 +72,10 @@ export const prepareBuilderRun = async ({
   await writeWorkflowState({
     path: workflowPath,
     state: nextState,
-    currentRevision: currentState.revision,
-  });
-
-  const expectedPaths = [workflowPath];
-
-  if (handoffExists) {
-    expectedPaths.push(handoffPath);
-  }
-
-  const checkpointCommit = await createWorkflowCheckpointCommit({
-    repositoryRoot: paths.getRepositoryRoot(),
-    expectedPaths,
   });
 
   return {
     specId,
-    revision: nextState.revision,
-    repositoryRoot: paths.getRepositoryRoot(),
-    checkpointCommit,
+    projectRoot: paths.getProjectRoot(),
   };
 };

package/src/workflow/escalation/openBuilderEscalation.ts

@@ -10,7 +10,6 @@ import type {
   NewEscalation,
 } from '#artifacts/escalation/schema.ts';
 import type { MaestroPaths } from '#MaestroPaths.ts';
-import { pathExists } from '#utils/path-exists.ts';
 import { readWorkflowState } from '#workflow/state/readWorkflowState.ts';
 import {
   WORKFLOW_EVENTS,
@@ -23,7 +22,7 @@ import { transitionWorkflow } from '#workflow/transitions.ts';
 export type OpenedBuilderEscalation = {
   escalation: Escalation;
   state: WorkflowState;
-  repositoryRoot: string;
+  projectRoot: string;
   workflowPath: string;
   escalationPath: string;
 };
@@ -40,7 +39,6 @@ export const openBuilderEscalation = async ({
   escalation,
 }: OpenBuilderEscalationInput): Promise<OpenedBuilderEscalation> => {
   const workflowPath = paths.getWorkflowPath(specId);
-  const handoffPath = paths.getBuilderHandoffPath(specId);
   const escalationsPath = paths.getEscalationsPath(specId);
   const currentState = await readWorkflowState(workflowPath);
 
@@ -56,10 +54,6 @@ export const openBuilderEscalation = async ({
     );
   }
 
-  if (await pathExists(handoffPath)) {
-    throw new Error('Builder terminal handoff already exists.');
-  }
-
   const nextState = transitionWorkflow({
     state: currentState,
     event: WORKFLOW_EVENTS.OPEN_ESCALATION,
@@ -70,20 +64,18 @@ export const openBuilderEscalation = async ({
   const created = await createEscalation({
     directory: escalationsPath,
     specId: currentState.specId,
-    revision: nextState.revision,
     escalation,
   });
 
   await writeWorkflowState({
     path: workflowPath,
     state: nextState,
-    currentRevision: currentState.revision,
   });
 
   return {
     escalation: created.escalation,
     state: nextState,
-    repositoryRoot: paths.getRepositoryRoot(),
+    projectRoot: paths.getProjectRoot(),
     workflowPath,
     escalationPath: created.path,
   };