vibe64 0.1.21 → 0.1.22

package/node_modules/@local/vibe64-runtime/src/server/workflowModules/coreLifecycle.js

@@ -5,14 +5,15 @@ import {
 import { deepFreeze } from "@local/vibe64-core/server/deepFreeze";
 import {
   PULL_REQUEST_BODY_DRAFT_ARTIFACT,
-  PULL_REQUEST_TITLE_DRAFT_ARTIFACT
+  PULL_REQUEST_TITLE_DRAFT_ARTIFACT,
+  REPORT_ARTIFACT
 } from "../workflowArtifacts.js";
 import { when } from "../workflowConditions.js";
 import {
+  LET_CODEX_DECIDE_INPUT,
   STEP_INPUT_KIND,
   STEP_STATUS,
   actionCreatedMetadata,
-  allMetadataExists,
   artifactIsReady,
   artifactText,
   assertAgentResultSource,
@@ -23,7 +24,6 @@ import {
   disableAction,
   machineState,
   markCommandActionStarted,
-  markPromptActionStarted,
   metadataExists,
   nextForSession,
   normalizeMachineInput,
@@ -45,14 +45,16 @@ const sessionCreatedStepId = "session_created";
 const workSourceSelectedStepId = "work_source_selected";
 const worktreeCreatedStepId = "worktree_created";
 const dependenciesInstalledStepId = "dependencies_installed";
-const projectValidatedStepId = "project_validated";
 const changesCommittedStepId = "changes_committed";
-const createPullRequestStepId = "create_pull_request";
-const prMergedStepId = "pr_merged";
-const mainCheckoutSyncedStepId = "main_checkout_synced";
+const createAndMergePullRequestStepId = "create_and_merge_pull_request";
 const sessionFinishedStepId = "session_finished";
 const installDependenciesActionId = "install_dependencies";
 const dependenciesInstalledMetadataName = "dependencies_installed";
+const syncMainCheckoutActionId = "sync_main_checkout";
+const mainCheckoutSyncedMetadataName = "main_checkout_synced";
+const mergePreparationSummaryMetadataName = "merge_preparation_summary";
+const finalReportStartMarker = "<!-- vibe64:final-report:start -->";
+const finalReportEndMarker = "<!-- vibe64:final-report:end -->";
 
 async function recordMergeIntent(ctx = {}) {
   await ctx.writeMetadata("autopilot_merge_intent", "merge_and_sync");
@@ -66,7 +68,7 @@ async function skipMergeAndFinish(ctx = {}) {
 }
 
 const coreLifecycleWorkflowIntentHandlers = deepFreeze({
-  [prMergedStepId]: {
+  [createAndMergePullRequestStepId]: {
     merge_and_sync: recordMergeIntent,
     skip_merge: skipMergeAndFinish
   }
@@ -84,15 +86,33 @@ const coreLifecycleStepDefinitionsById = deepFreeze({
       {
         disabledReason: "Work source is already selected.",
         disabledWhen: [when.metadataExists("work_source")],
+        advanceOnSuccess: true,
         icon: "branch",
-        id: "use_new_branch",
-        label: "Use new branch",
+        id: "use_new_issue",
+        label: "Start fresh with a new issue",
         type: "adapter"
       },
       {
-        adapterCapability: "use_existing_pr",
         disabledReason: "Work source is already selected.",
         disabledWhen: [when.metadataExists("work_source")],
+        advanceOnSuccess: true,
+        icon: "github",
+        id: "use_existing_issue",
+        inputFields: [
+          {
+            label: "Issue URL or number",
+            name: "issueRef",
+            placeholder: "123, #123, or https://github.com/org/repo/issues/123",
+            requiredMessage: "Issue URL or number is required."
+          }
+        ],
+        label: "Solve existing issue",
+        type: "adapter"
+      },
+      {
+        disabledReason: "Work source is already selected.",
+        disabledWhen: [when.metadataExists("work_source")],
+        advanceOnSuccess: true,
         icon: "github",
         id: "use_existing_pr",
         inputFields: [
@@ -105,26 +125,70 @@ const coreLifecycleStepDefinitionsById = deepFreeze({
         ],
         label: "Use existing PR",
         type: "adapter"
+      },
+      {
+        disabledReason: "Work source is already selected.",
+        disabledWhen: [when.metadataExists("work_source")],
+        advanceOnSuccess: true,
+        icon: "message-square-plus",
+        id: "use_description",
+        label: "Describe work without an issue",
+        type: "adapter"
       }
     ],
     autopilot: {
-      actionId: "use_new_branch",
-      advanceOnSuccess: true,
       completeWhen: [when.metadataExists("work_source")],
-      label: "Choose work source"
+      kind: "work_source",
+      label: "Choose starting point",
+      stop: true
     },
-    description: "Choose whether this session starts from a new branch or an existing pull request.",
+    description: "Choose whether this session starts fresh with a new issue, solves an existing issue, builds on an existing pull request, or starts from a plain work description.",
     id: workSourceSelectedStepId,
-    interaction: {
-      kind: "run_action",
-      primaryActionLabel: "Use new branch",
-      title: "Choose work source"
-    },
-    label: "Choose work source",
+    label: "Choose starting point",
     next: {
-      disabledReason: "Choose a work source before continuing.",
+      disabledReason: "Choose a starting point before continuing.",
       enabledWhen: [when.metadataExists("work_source")]
     },
+    presentation: {
+      stop: {
+        intents: [
+          {
+            actionId: "use_new_issue",
+            id: "use_new_issue",
+            label: "Start fresh with a new issue",
+            style: "primary",
+            type: "action"
+          },
+          {
+            actionId: "use_existing_issue",
+            id: "use_existing_issue",
+            label: "Solve existing issue",
+            style: "secondary",
+            type: "action"
+          },
+          {
+            actionId: "use_existing_pr",
+            id: "use_existing_pr",
+            label: "Use existing PR",
+            style: "secondary",
+            type: "action"
+          },
+          {
+            actionId: "use_description",
+            id: "use_description",
+            label: "Describe work without an issue",
+            style: "secondary",
+            type: "action"
+          }
+        ],
+        screen: {
+          kind: "work_source",
+          message: "Start fresh with a new issue, solve an existing issue, build on an existing pull request, or describe work without creating an issue.",
+          sections: [],
+          title: "Choose starting point"
+        }
+      }
+    },
     rewindable: false
   },
   [worktreeCreatedStepId]: {
@@ -194,62 +258,6 @@ const coreLifecycleStepDefinitionsById = deepFreeze({
       metadata: [dependenciesInstalledMetadataName, "dependencies_path"]
     }
   },
-  [projectValidatedStepId]: {
-    actions: [
-      {
-        adapterCapability: "update_code_index",
-        icon: "sync",
-        id: "update_code_index",
-        label: "Update code index",
-        type: "command"
-      },
-      {
-        adapterCapability: "run_automated_checks",
-        enabledWhen: [when.metadataExists("code_index_updated")],
-        enabledWhenReason: "Update the code index before running automated checks.",
-        icon: "run",
-        id: "run_automated_checks",
-        label: "Run automated checks",
-        type: "command"
-      }
-    ],
-    autopilot: {
-      actionSequence: [
-        {
-          actionId: "update_code_index",
-          completeWhen: [when.metadataExists("code_index_updated")],
-          label: "Update code index"
-        },
-        {
-          actionId: "run_automated_checks",
-          completeWhen: [when.metadataExists("automated_checks_passed")],
-          label: "Run automated checks"
-        }
-      ],
-      label: "Validate project"
-    },
-    description: "Update the adapter-provided code index and run automated checks.",
-    id: projectValidatedStepId,
-    label: "Validate project",
-    next: {
-      disabledReason: "Update the code index and run automated checks successfully before continuing.",
-      enabledWhen: [
-        when.metadataExists("code_index_updated"),
-        when.metadataExists("automated_checks_passed")
-      ]
-    },
-    rewindCleanup: {
-      actionResults: ["update_code_index", "run_automated_checks"],
-      metadata: [
-        "code_index_command_source",
-        "code_index_package_manager",
-        "code_index_path",
-        "code_index_updated",
-        "automated_checks_package_manager",
-        "automated_checks_passed"
-      ]
-    }
-  },
   [changesCommittedStepId]: {
     actions: [
       {
@@ -280,7 +288,7 @@ const coreLifecycleStepDefinitionsById = deepFreeze({
       metadata: ["accepted_commit", "branch_pushed"]
     }
   },
-  [createPullRequestStepId]: {
+  [createAndMergePullRequestStepId]: {
     actions: [
       {
         enabledWhen: [when.metadataExists("pr_url")],
@@ -291,8 +299,14 @@ const coreLifecycleStepDefinitionsById = deepFreeze({
         type: "link"
       },
       {
+        auditMessage: "Draft pull request.",
         disabledReason: "Pull request details are already ready for review.",
-        disabledWhen: [when.allArtifactsReady(PULL_REQUEST_TITLE_DRAFT_ARTIFACT, PULL_REQUEST_BODY_DRAFT_ARTIFACT)],
+        disabledWhen: [
+          when.any(
+            when.allArtifactsReady(PULL_REQUEST_TITLE_DRAFT_ARTIFACT, PULL_REQUEST_BODY_DRAFT_ARTIFACT),
+            when.metadataExists("pr_url")
+          )
+        ],
         id: "resolve_pull_request",
         label: "Draft PR",
         promptId: "resolve_pull_request",
@@ -300,6 +314,7 @@ const coreLifecycleStepDefinitionsById = deepFreeze({
       },
       {
         adapterCapability: "create_pr_on_gh",
+        auditMessage: "Pull request draft accepted; creating GitHub pull request.",
         disabledReason: "Commit and push changes before creating the GitHub pull request.",
         disabledWhen: [when.metadataExists("pr_url")],
         disabledWhenReason: "The GitHub pull request already exists.",
@@ -312,63 +327,11 @@ const coreLifecycleStepDefinitionsById = deepFreeze({
         icon: "github",
         id: "create_pr_on_gh",
         label: "Create PR on GH",
+        saveCurrentStepInputBeforeRun: true,
         type: "command"
-      }
-    ],
-    autopilot: {
-      actionSequence: [
-        {
-          actionId: "resolve_pull_request",
-          completeWhen: [when.allArtifactsReady(PULL_REQUEST_TITLE_DRAFT_ARTIFACT, PULL_REQUEST_BODY_DRAFT_ARTIFACT)],
-          label: "Draft PR"
-        },
-        {
-          actionId: "create_pr_on_gh",
-          completeWhen: [when.metadataExists("pr_url")],
-          label: "Create PR on GH"
-        }
-      ],
-      label: "Create pull request"
-    },
-    description: "Submit the pull request body and create the GitHub pull request.",
-    id: createPullRequestStepId,
-    label: "Create pull request",
-    next: {
-      disabledReason: "Create the pull request before continuing.",
-      enabledWhen: [when.metadataExists("pr_url")]
-    },
-    rewindCleanup: {
-      actionResults: ["create_pr_on_gh"],
-      artifacts: [
-        PULL_REQUEST_BODY_DRAFT_ARTIFACT,
-        PULL_REQUEST_TITLE_DRAFT_ARTIFACT,
-        "create_pull_request.url.txt",
-        "create_pull_request.number.txt",
-        "create_pull_request.source.txt"
-      ],
-      metadata: [
-        {
-          name: "pr_url",
-          unlessMetadata: {
-            name: "pr_source",
-            value: "existing"
-          }
-        },
-        "pr_number",
-        "pr_title",
-        {
-          name: "pr_source",
-          unlessMetadata: {
-            name: "pr_source",
-            value: "existing"
-          }
-        }
-      ]
-    }
-  },
-  [prMergedStepId]: {
-    actions: [
+      },
       {
+        auditMessage: "Prepare pull request for merge.",
         disabledReason: "Create the pull request before preparing for merge.",
         disabledWhen: [
           when.metadataExists("pr_merged"),
@@ -383,6 +346,7 @@ const coreLifecycleStepDefinitionsById = deepFreeze({
       },
       {
         adapterCapability: "merge_pr",
+        auditMessage: "Merge pull request.",
         disabledReason: "Create the pull request before merging.",
         disabledWhen: [
           when.metadataExists("pr_merged"),
@@ -396,6 +360,26 @@ const coreLifecycleStepDefinitionsById = deepFreeze({
         type: "command"
       },
       {
+        adapterCapability: syncMainCheckoutActionId,
+        auditMessage: "Update main checkout after merge.",
+        disabledReason: "Merge the pull request before syncing the main checkout.",
+        disabledWhen: [
+          when.metadataExists(mainCheckoutSyncedMetadataName),
+          when.metadataExists("merge_skipped")
+        ],
+        disabledWhenReason: "The main checkout sync has already been resolved.",
+        enabledWhen: [
+          when.metadataExists("pr_url"),
+          when.metadataExists("pr_merged")
+        ],
+        enabledWhenReason: "Merge the pull request before syncing the main checkout.",
+        icon: "sync",
+        id: syncMainCheckoutActionId,
+        label: "Sync main checkout",
+        type: "command"
+      },
+      {
+        auditMessage: "Pull request will not be merged.",
         disabledReason: "A merge decision has already been recorded.",
         disabledWhen: [
           when.metadataExists("pr_merged"),
@@ -409,17 +393,28 @@ const coreLifecycleStepDefinitionsById = deepFreeze({
       }
     ],
     autopilot: {
-      kind: "merge_review",
-      stop: true
+      actionSequence: [
+        {
+          actionId: "resolve_pull_request",
+          completeWhen: [when.allArtifactsReady(PULL_REQUEST_TITLE_DRAFT_ARTIFACT, PULL_REQUEST_BODY_DRAFT_ARTIFACT)],
+          label: "Draft PR"
+        },
+        {
+          actionId: "create_pr_on_gh",
+          completeWhen: [when.metadataExists("pr_url")],
+          label: "Create PR on GH"
+        }
+      ],
+      label: "Create pull request, possibly merge"
     },
-    description: "Prepare and merge the pull request.",
-    id: prMergedStepId,
-    label: "Merge PR",
+    description: "Submit the pull request body, create the GitHub pull request, then merge and sync the main checkout or skip merging.",
+    id: createAndMergePullRequestStepId,
+    label: "Create pull request, possibly merge",
     next: {
-      disabledReason: "Merge the pull request or choose not to merge before continuing.",
+      disabledReason: "Create the pull request, then merge and sync the main checkout or choose not to merge before continuing.",
       enabledWhen: [
         when.any(
-          when.metadataExists("pr_merged"),
+          when.metadataExists(mainCheckoutSyncedMetadataName),
           when.metadataExists("merge_skipped")
         )
       ]
@@ -432,18 +427,22 @@ const coreLifecycleStepDefinitionsById = deepFreeze({
           metadataName: "autopilot_merge_intent",
           metadataValue: "merge_and_sync",
           prepareActionId: "prepare_for_merge",
+          syncActionId: syncMainCheckoutActionId,
+          syncedMetadataName: mainCheckoutSyncedMetadataName,
           skippedMetadataName: "merge_skipped"
         }
       },
       stop: {
         intents: [
           {
+            auditMessage: "Merge pull request and update main checkout.",
             enabledWhenAction: "prepare_for_merge",
             id: "merge_and_sync",
             label: "Merge and update main checkout",
             style: "primary"
           },
           {
+            auditMessage: "Pull request will not be merged.",
             enabledWhenAction: "skip_merge",
             id: "skip_merge",
             label: "Do not merge"
@@ -458,45 +457,37 @@ const coreLifecycleStepDefinitionsById = deepFreeze({
       }
     },
     rewindCleanup: {
-      actionResults: ["prepare_for_merge", "merge_pr", "skip_merge"],
-      metadata: ["pr_merged", "merge_skipped", "autopilot_merge_intent"]
-    }
-  },
-  [mainCheckoutSyncedStepId]: {
-    actions: [
-      {
-        adapterCapability: "sync_main_checkout",
-        disabledReason: "Merge the pull request before syncing the main checkout.",
-        enabledWhen: [
-          when.metadataExists("pr_url"),
-          when.metadataExists("pr_merged")
-        ],
-        icon: "sync",
-        id: "sync_main_checkout",
-        label: "Sync main checkout",
-        type: "command"
-      }
-    ],
-    autopilot: {
-      actionId: "sync_main_checkout",
-      completeWhen: [when.metadataExists("main_checkout_synced")],
-      label: "Sync main checkout"
-    },
-    description: "Sync the main checkout after a successful merge.",
-    id: mainCheckoutSyncedStepId,
-    label: "Sync main checkout",
-    next: {
-      disabledReason: "Sync the main checkout after merging before continuing.",
-      enabledWhen: [
-        when.any(
-          when.metadataExists("main_checkout_synced"),
-          when.metadataExists("merge_skipped")
-        )
+      actionResults: ["resolve_pull_request", "create_pr_on_gh", "prepare_for_merge", "merge_pr", syncMainCheckoutActionId, "skip_merge"],
+      artifacts: [
+        PULL_REQUEST_BODY_DRAFT_ARTIFACT,
+        PULL_REQUEST_TITLE_DRAFT_ARTIFACT,
+        "create_and_merge_pull_request.url.txt",
+        "create_and_merge_pull_request.number.txt",
+        "create_and_merge_pull_request.source.txt"
+      ],
+      metadata: [
+        {
+          name: "pr_url",
+          unlessMetadata: {
+            name: "pr_source",
+            value: "existing"
+          }
+        },
+        "pr_number",
+        "pr_title",
+        {
+          name: "pr_source",
+          unlessMetadata: {
+            name: "pr_source",
+            value: "existing"
+          }
+        },
+        "pr_merged",
+        mainCheckoutSyncedMetadataName,
+        "merge_skipped",
+        "autopilot_merge_intent",
+        mergePreparationSummaryMetadataName
       ]
-    },
-    rewindCleanup: {
-      actionResults: ["sync_main_checkout"],
-      metadata: ["main_checkout_synced"]
     }
   },
   [sessionFinishedStepId]: {
@@ -507,7 +498,7 @@ const coreLifecycleStepDefinitionsById = deepFreeze({
         enabledWhen: [
           when.metadataExists("pr_url"),
           when.any(
-            when.metadataExists("main_checkout_synced"),
+            when.metadataExists(mainCheckoutSyncedMetadataName),
             when.metadataExists("merge_skipped")
           )
         ],
@@ -599,7 +590,7 @@ const workSourceSelectedMachine = {
       default:
         return {
           next: nextForSession(context.session, {
-            disabledReason: "Choose a work source before continuing."
+            disabledReason: "Choose a starting point before continuing."
           }),
           stepMachine: publicState(this, state)
         };
@@ -607,7 +598,7 @@ const workSourceSelectedMachine = {
   },
 
   async actionFinished(context = {}) {
-    if (!["use_new_branch", "use_existing_pr"].includes(context.actionId)) {
+    if (!["use_new_issue", "use_existing_issue", "use_existing_pr", "use_description"].includes(context.actionId)) {
       return;
     }
 
@@ -886,47 +877,6 @@ const dependenciesInstalledMachine = {
   }
 };
 
-const projectValidatedMachine = {
-  stepId: projectValidatedStepId,
-
-  initialState(context = {}) {
-    return allMetadataExists(context.session, ["code_index_updated", "automated_checks_passed"])
-      ? machineState(STEP_STATUS.DONE)
-      : machineState(STEP_STATUS.READY);
-  },
-
-  async view(context = {}) {
-    let state = await readState(context, this);
-    if (allMetadataExists(context.session, ["code_index_updated", "automated_checks_passed"])) {
-      state = machineState(STEP_STATUS.DONE);
-    }
-    return commandStepView(context, this, state, {
-      disabledReason: "Update the code index and run automated checks successfully before continuing.",
-      failurePrompt: "The project validation command failed. Explain what should happen, then retry validation.",
-      failureTitle: "Validation needs attention"
-    });
-  },
-
-  async submitInput(context = {}) {
-    return submitCommandFailureInput(context, this);
-  },
-
-  async actionStarted(context = {}) {
-    return markCommandActionStarted(context, this, ["update_code_index", "run_automated_checks"]);
-  },
-
-  async actionFinished(context = {}) {
-    return writeCommandActionFinishedState(context, this, {
-      actionIds: ["update_code_index", "run_automated_checks"],
-      done: allMetadataExists(await context.runtime.getSession(context.session.sessionId), [
-        "code_index_updated",
-        "automated_checks_passed"
-      ]),
-      failureTitle: "Validation needs attention"
-    });
-  }
-};
-
 const changesCommittedMachine = {
   stepId: changesCommittedStepId,
 
@@ -965,37 +915,180 @@ const changesCommittedMachine = {
   }
 };
 
-const pullRequestMergedMachine = {
+const pullRequestPhase = Object.freeze({
+  CREATING_PR: "creating_pr",
+  DRAFTING: "drafting",
+  MERGE_READY: "merge_ready",
+  MERGING: "merging",
+  PREPARING_MERGE: "preparing_merge",
+  REVIEW_DRAFT: "review_draft",
+  SYNC_READY: "sync_ready",
+  SYNCING_MAIN: "syncing_main"
+});
+
+function pullRequestStepComplete(session = {}) {
+  return metadataExists(session, mainCheckoutSyncedMetadataName) || metadataExists(session, "merge_skipped");
+}
+
+function mainCheckoutSyncPending(session = {}) {
+  return metadataExists(session, "pr_merged") && !metadataExists(session, mainCheckoutSyncedMetadataName);
+}
+
+function mergeReviewAutopilot() {
+  return {
+    kind: "merge_review",
+    stage: null,
+    stop: true
+  };
+}
+
+const createAndMergePullRequestMachine = {
   promptActionId: "prepare_for_merge",
-  stepId: prMergedStepId,
+  stepId: createAndMergePullRequestStepId,
 
   initialState(context = {}) {
-    return metadataExists(context.session, "pr_merged") || metadataExists(context.session, "merge_skipped")
-      ? machineState(STEP_STATUS.DONE)
-      : machineState(STEP_STATUS.READY);
+    if (pullRequestStepComplete(context.session)) {
+      return machineState(STEP_STATUS.DONE);
+    }
+    if (mainCheckoutSyncPending(context.session)) {
+      return machineState(STEP_STATUS.READY, {
+        phase: pullRequestPhase.SYNC_READY
+      });
+    }
+    if (metadataExists(context.session, "pr_url")) {
+      return machineState(STEP_STATUS.READY, {
+        phase: pullRequestPhase.MERGE_READY
+      });
+    }
+    return pullRequestFilesAreReady(context.session)
+      ? machineState(STEP_STATUS.CONFIRM_FILES, {
+          phase: pullRequestPhase.REVIEW_DRAFT
+        })
+      : machineState(STEP_STATUS.READY, {
+          phase: pullRequestPhase.DRAFTING
+        });
   },
 
   async view(context = {}) {
     let state = await readState(context, this);
-    if (metadataExists(context.session, "pr_merged") || metadataExists(context.session, "merge_skipped")) {
+    if (pullRequestStepComplete(context.session)) {
       state = machineState(STEP_STATUS.DONE);
+    } else if (mainCheckoutSyncPending(context.session) && ![
+      STEP_STATUS.ATTEMPTING_EXECUTION,
+      STEP_STATUS.WAITING_FOR_INPUT
+    ].includes(state.status)) {
+      state = machineState(STEP_STATUS.READY, {
+        phase: pullRequestPhase.SYNC_READY
+      });
+    } else if (metadataExists(context.session, "pr_url") && ![
+      STEP_STATUS.AWAITING_AGENT_RESULT,
+      STEP_STATUS.ATTEMPTING_EXECUTION,
+      STEP_STATUS.WAITING_FOR_INPUT
+    ].includes(state.status)) {
+      state = machineState(STEP_STATUS.READY, {
+        phase: pullRequestPhase.MERGE_READY,
+        promptComplete: state.promptComplete === true
+      });
+    } else if (
+      pullRequestFilesAreReady(context.session) &&
+      state.status !== STEP_STATUS.CONFIRM_FILES &&
+      ![
+        pullRequestPhase.CREATING_PR,
+        pullRequestPhase.PREPARING_MERGE,
+        pullRequestPhase.MERGING,
+        pullRequestPhase.SYNCING_MAIN
+      ].includes(state.phase)
+    ) {
+      state = machineState(STEP_STATUS.CONFIRM_FILES, {
+        phase: pullRequestPhase.REVIEW_DRAFT
+      });
     }
+
     switch (state.status) {
       case STEP_STATUS.DONE:
         return promptStepDoneView(context, this, state);
 
+      case STEP_STATUS.CONFIRM_FILES: {
+        const values = await readPullRequestFieldValues(context);
+        return {
+          interaction: pullRequestInputInteraction(values),
+          next: nextForSession(context.session, {
+            disabledReason: "Create the pull request before choosing whether to merge."
+          }),
+          stepMachine: publicState(this, {
+            ...state,
+            message: state.message || "Review the pull request draft."
+          })
+        };
+      }
+
       case STEP_STATUS.WAITING_FOR_INPUT:
+        if ([pullRequestPhase.CREATING_PR, pullRequestPhase.MERGING, pullRequestPhase.SYNCING_MAIN].includes(state.phase)) {
+          const waitingActionId = state.phase === pullRequestPhase.MERGING
+            ? "merge_pr"
+            : (state.phase === pullRequestPhase.SYNCING_MAIN ? syncMainCheckoutActionId : "create_pr_on_gh");
+          return {
+            actions: disableAction(
+              context.session,
+              waitingActionId,
+              state.phase === pullRequestPhase.MERGING
+                ? "Resolve the merge command before retrying."
+                : (state.phase === pullRequestPhase.SYNCING_MAIN
+                    ? "Resolve the main checkout sync command before retrying."
+                    : "Resolve the pull request command before retrying.")
+            ),
+            interaction: commandFailureInteraction({
+              prompt: state.message || (state.phase === pullRequestPhase.SYNCING_MAIN
+                ? "The main checkout sync command failed. Explain what should happen, then retry it."
+                : "The pull request command failed. Explain what should happen, then retry."),
+              title: state.title || (state.phase === pullRequestPhase.SYNCING_MAIN
+                ? "Main checkout sync needs attention"
+                : "Pull request needs attention")
+            }),
+            next: nextForSession(context.session, {
+              disabledReason: state.phase === pullRequestPhase.SYNCING_MAIN
+                ? "Resolve the main checkout sync command before continuing."
+                : "Resolve the pull request command before continuing."
+            }),
+            stepMachine: publicState(this, state)
+          };
+        }
         return promptStepWaitingForInputView(context, this, {
           ...state,
-          message: state.message || "The merge step needs input before it can continue."
+          message: state.message || "The pull request step needs input before it can continue."
+        }, {
+          actionId: state.phase === pullRequestPhase.DRAFTING ? "resolve_pull_request" : "prepare_for_merge",
+          prompt: state.message || "The pull request step needs input before it can continue.",
+          skipInput: LET_CODEX_DECIDE_INPUT,
+          title: state.phase === pullRequestPhase.DRAFTING ? "Pull request needs input" : "Merge needs input"
         });
 
       case STEP_STATUS.READY:
+        if (state.phase === pullRequestPhase.MERGE_READY) {
+          return {
+            next: nextForSession(context.session, {
+              disabledReason: "Merge the pull request and sync the main checkout, or choose not to merge before continuing."
+            }),
+            stepMachine: publicState(this, state),
+            workflowAutopilot: mergeReviewAutopilot()
+          };
+        }
+        if (state.phase === pullRequestPhase.SYNC_READY) {
+          return {
+            next: nextForSession(context.session, {
+              disabledReason: "Sync the main checkout after merging before continuing."
+            }),
+            stepMachine: publicState(this, state),
+            workflowAutopilot: mergeReviewAutopilot()
+          };
+        }
+        return promptStepWaitingView(context, this, state, "Create the pull request before choosing whether to merge.");
+
       case STEP_STATUS.AWAITING_AGENT_RESULT:
       case STEP_STATUS.ATTEMPTING_EXECUTION:
       case STEP_STATUS.FAILED:
       default:
-        return promptStepWaitingView(context, this, state, "Merge the pull request or choose not to merge before continuing.");
+        return promptStepWaitingView(context, this, state, "Create the pull request, then merge and sync the main checkout or choose not to merge before continuing.");
     }
   },
 
@@ -1003,52 +1096,119 @@ const pullRequestMergedMachine = {
     const state = await readState(context, this);
     const input = normalizeMachineInput(context.input);
     switch (state.status) {
-      case STEP_STATUS.READY:
       case STEP_STATUS.AWAITING_AGENT_RESULT:
       case STEP_STATUS.WAITING_FOR_INPUT:
+      case STEP_STATUS.CONFIRM_FILES:
       case STEP_STATUS.FAILED:
         if (state.status === STEP_STATUS.AWAITING_AGENT_RESULT) {
           assertAgentResultSource(context.session, input);
         }
         if (input.kind === STEP_INPUT_KIND.WAITING_FOR_INPUT) {
           await writeState(context, this, machineState(STEP_STATUS.WAITING_FOR_INPUT, {
-            from: state.status === STEP_STATUS.ATTEMPTING_EXECUTION
-              ? STEP_STATUS.ATTEMPTING_EXECUTION
-              : STEP_STATUS.AWAITING_AGENT_RESULT,
             message: input.message,
+            phase: state.phase || pullRequestPhase.DRAFTING,
             source: input.source
           }));
           return;
         }
         if (input.kind === STEP_INPUT_KIND.USER_RESPONSE || input.kind === STEP_INPUT_KIND.CONSIDER_RESOLVED) {
+          if (state.phase === pullRequestPhase.CREATING_PR) {
+            await writeState(context, this, pullRequestFilesAreReady(context.session)
+              ? machineState(STEP_STATUS.CONFIRM_FILES, {
+                  message: input.message,
+                  phase: pullRequestPhase.REVIEW_DRAFT,
+                  response: input.text || input.fields.response,
+                  source: input.source
+                })
+              : machineState(STEP_STATUS.READY, {
+                  message: input.message,
+                  phase: pullRequestPhase.DRAFTING,
+                  response: input.text || input.fields.response,
+                  source: input.source
+                }));
+            return;
+          }
+          if (state.phase === pullRequestPhase.SYNCING_MAIN) {
+            await writeState(context, this, machineState(STEP_STATUS.READY, {
+              phase: pullRequestPhase.SYNC_READY,
+              response: input.text || input.fields.response,
+              source: input.source
+            }));
+            return;
+          }
           await writeState(context, this, machineState(STEP_STATUS.READY, {
+            phase: state.phase || pullRequestPhase.MERGE_READY,
             response: input.text || input.fields.response,
             source: input.source
           }));
           return;
         }
-        if (input.kind === STEP_INPUT_KIND.READY) {
+        if (input.kind === STEP_INPUT_KIND.READY && state.phase === pullRequestPhase.PREPARING_MERGE) {
+          await writeMergePreparationSummary(context, input.fields.mergePreparationSummary);
           await writeState(context, this, machineState(STEP_STATUS.READY, {
             message: input.message,
+            phase: pullRequestPhase.MERGE_READY,
             promptComplete: true,
             source: input.source
           }));
           return;
         }
+        if (input.kind === STEP_INPUT_KIND.READY || input.kind === STEP_INPUT_KIND.CONFIRM_FILES) {
+          await writePullRequestFieldValues(context, input.fields);
+          await writeState(context, this, machineState(STEP_STATUS.CONFIRM_FILES, {
+            phase: pullRequestPhase.REVIEW_DRAFT,
+            source: input.source
+          }));
+          return;
+        }
         throw unsupportedInputKind(input.kind, this.stepId);
 
+      case STEP_STATUS.READY:
       case STEP_STATUS.ATTEMPTING_EXECUTION:
       case STEP_STATUS.DONE:
       default:
-        throw vibe64Error("The merge step cannot accept input right now.", "vibe64_step_input_not_available");
+        throw vibe64Error("The pull request step cannot accept input right now.", "vibe64_step_input_not_available");
     }
   },
 
   async actionStarted(context = {}) {
+    const state = await readState(context, this);
+    if (context.actionId === "resolve_pull_request") {
+      await writeState(context, this, machineState(STEP_STATUS.AWAITING_AGENT_RESULT, {
+        phase: pullRequestPhase.DRAFTING,
+        response: state.response,
+        source: state.source
+      }));
+      return;
+    }
     if (context.actionId === "prepare_for_merge") {
-      return markPromptActionStarted(context, this, "prepare_for_merge");
+      await writeState(context, this, machineState(STEP_STATUS.AWAITING_AGENT_RESULT, {
+        phase: pullRequestPhase.PREPARING_MERGE,
+        response: state.response,
+        source: state.source
+      }));
+      return;
+    }
+    if (context.actionId === "create_pr_on_gh") {
+      await writeState(context, this, machineState(STEP_STATUS.ATTEMPTING_EXECUTION, {
+        actionId: context.actionId,
+        phase: pullRequestPhase.CREATING_PR
+      }));
+      return;
+    }
+    if (context.actionId === "merge_pr") {
+      await writeState(context, this, machineState(STEP_STATUS.ATTEMPTING_EXECUTION, {
+        actionId: context.actionId,
+        phase: pullRequestPhase.MERGING
+      }));
+      return;
+    }
+    if (context.actionId === syncMainCheckoutActionId) {
+      await writeState(context, this, machineState(STEP_STATUS.ATTEMPTING_EXECUTION, {
+        actionId: context.actionId,
+        phase: pullRequestPhase.SYNCING_MAIN
+      }));
     }
-    return markCommandActionStarted(context, this, ["merge_pr"]);
   },
 
   async actionFinished(context = {}) {
@@ -1056,56 +1216,84 @@ const pullRequestMergedMachine = {
       await writeState(context, this, machineState(STEP_STATUS.DONE));
       return;
     }
-    return writeCommandActionFinishedState(context, this, {
-      actionIds: ["merge_pr"],
-      done: await actionCreatedMetadata(context, "pr_merged"),
-      failureTitle: "Merge needs attention"
-    });
-  },
-
-  promptInstruction() {
-    return currentStepHelperInstruction({
-      doneMeaning: "The pull request and main checkout are ready for the merge command.",
-      waitingForInputMeaning: "The merge preparation found a blocker that needs user input."
-    });
-  }
-};
-
-const mainCheckoutSyncedMachine = {
-  stepId: mainCheckoutSyncedStepId,
-
-  initialState(context = {}) {
-    return metadataExists(context.session, "main_checkout_synced") || metadataExists(context.session, "merge_skipped")
-      ? machineState(STEP_STATUS.DONE)
-      : machineState(STEP_STATUS.READY);
-  },
-
-  async view(context = {}) {
-    let state = await readState(context, this);
-    if (metadataExists(context.session, "main_checkout_synced") || metadataExists(context.session, "merge_skipped")) {
-      state = machineState(STEP_STATUS.DONE);
+    if (context.actionId === "create_pr_on_gh") {
+      await writeState(context, this, await actionCreatedMetadata(context, "pr_url")
+        ? machineState(STEP_STATUS.READY, {
+            phase: pullRequestPhase.MERGE_READY
+          })
+        : machineState(STEP_STATUS.WAITING_FOR_INPUT, {
+            from: STEP_STATUS.ATTEMPTING_EXECUTION,
+            message: normalizeText(context.actionResult?.message),
+            output: normalizeText(context.actionResult?.output),
+            phase: pullRequestPhase.CREATING_PR,
+            title: "Pull request needs attention"
+          }));
+      return;
+    }
+    if (context.actionId === "merge_pr") {
+      await writeState(context, this, await actionCreatedMetadata(context, "pr_merged")
+        ? machineState(STEP_STATUS.READY, {
+            phase: pullRequestPhase.SYNC_READY
+          })
+        : machineState(STEP_STATUS.WAITING_FOR_INPUT, {
+            from: STEP_STATUS.ATTEMPTING_EXECUTION,
+            message: normalizeText(context.actionResult?.message),
+            output: normalizeText(context.actionResult?.output),
+            phase: pullRequestPhase.MERGING,
+            title: "Merge needs attention"
+          }));
+      return;
+    }
+    if (context.actionId === syncMainCheckoutActionId) {
+      await writeState(context, this, await actionCreatedMetadata(context, mainCheckoutSyncedMetadataName)
+        ? machineState(STEP_STATUS.DONE)
+        : machineState(STEP_STATUS.WAITING_FOR_INPUT, {
+            from: STEP_STATUS.ATTEMPTING_EXECUTION,
+            message: normalizeText(context.actionResult?.message),
+            output: normalizeText(context.actionResult?.output),
+            phase: pullRequestPhase.SYNCING_MAIN,
+            title: "Main checkout sync needs attention"
+          }));
     }
-    return commandStepView(context, this, state, {
-      disabledReason: "Sync the main checkout after merging before continuing.",
-      failurePrompt: "The main checkout sync command failed. Explain what should happen, then retry it.",
-      failureTitle: "Main checkout sync needs attention"
-    });
-  },
-
-  async submitInput(context = {}) {
-    return submitCommandFailureInput(context, this);
   },
 
-  async actionStarted(context = {}) {
-    return markCommandActionStarted(context, this, ["sync_main_checkout"]);
+  inputCompletionMessage(context = {}) {
+    const input = normalizeMachineInput(context.input);
+    if (input.kind !== STEP_INPUT_KIND.READY && input.kind !== STEP_INPUT_KIND.CONFIRM_FILES) {
+      return "";
+    }
+    if (
+      context.session.stepMachine?.phase === pullRequestPhase.PREPARING_MERGE ||
+      Object.hasOwn(input.fields || {}, "mergePreparationSummary")
+    ) {
+      return "Merge preparation completed.";
+    }
+    if (input.source === "codex") {
+      return pullRequestDraftConversationMessage(input, "Proposed");
+    }
+    if (input.source === "ui") {
+      return pullRequestDraftConversationMessage(input, "Saved");
+    }
+    return "Pull request draft submitted for review.";
   },
 
-  async actionFinished(context = {}) {
-    return writeCommandActionFinishedState(context, this, {
-      actionIds: ["sync_main_checkout"],
-      done: await actionCreatedMetadata(context, "main_checkout_synced"),
-      failureTitle: "Main checkout sync needs attention"
-    });
+  promptInstruction({ action = {} } = {}) {
+    return normalizeText(action.id) === "prepare_for_merge"
+      ? currentStepHelperInstruction({
+          doneFields: {
+            mergePreparationSummary: "Markdown summary of extra merge-preparation work performed after pull request creation. Leave empty when no extra work was needed."
+          },
+          doneMeaning: "The pull request and main checkout are ready for the merge command.",
+          waitingForInputMeaning: "The merge preparation found a blocker that needs user input."
+        })
+      : currentStepHelperInstruction({
+          doneFields: {
+            body: "Markdown pull request body",
+            title: "Pull request title"
+          },
+          doneMeaning: "The pull request title and body are ready for user confirmation.",
+          waitingForInputMeaning: "You cannot draft the pull request without a user decision or missing repository context."
+        });
   }
 };
 
@@ -1168,6 +1356,7 @@ async function readPullRequestFieldValues(context = {}) {
 async function writePullRequestFieldValues(context = {}, fields = {}) {
   const title = requireInputValue(fields.title, "Pull request title is required.");
   const body = requireInputValue(fields.body, "Pull request body is required.");
+  const bodyWithReport = await pullRequestBodyWithFinalReport(context, body);
   await Promise.all([
     context.runtime.store.writeArtifact(
       context.session.sessionId,
@@ -1177,11 +1366,70 @@ async function writePullRequestFieldValues(context = {}, fields = {}) {
     context.runtime.store.writeArtifact(
       context.session.sessionId,
       PULL_REQUEST_BODY_DRAFT_ARTIFACT,
-      artifactText(body)
+      artifactText(bodyWithReport)
     )
   ]);
 }
 
+async function pullRequestBodyWithFinalReport(context = {}, body = "") {
+  const normalizedBody = normalizeText(body);
+  if (normalizedBody.includes(finalReportStartMarker)) {
+    return normalizedBody;
+  }
+  const report = normalizeText(await context.runtime.store.readArtifact(context.session.sessionId, REPORT_ARTIFACT));
+  if (!report) {
+    return normalizedBody;
+  }
+  return [
+    normalizedBody,
+    "",
+    finalReportStartMarker,
+    "## Vibe64 final report",
+    "",
+    "<details>",
+    "<summary>Final session report</summary>",
+    "",
+    report,
+    "",
+    "</details>",
+    finalReportEndMarker
+  ].join("\n");
+}
+
+async function writeMergePreparationSummary(context = {}, summary = "") {
+  const normalizedSummary = normalizeText(summary);
+  if (normalizedSummary) {
+    await context.runtime.store.writeMetadataValue(
+      context.session.sessionId,
+      mergePreparationSummaryMetadataName,
+      normalizedSummary
+    );
+    return;
+  }
+  await context.runtime.store.deleteMetadataValue(
+    context.session.sessionId,
+    mergePreparationSummaryMetadataName
+  );
+}
+
+function conversationSection(label = "", value = "") {
+  return [
+    `${label}:`,
+    normalizeText(value) || "(empty)"
+  ].join("\n");
+}
+
+function pullRequestDraftConversationMessage(input = {}, verb = "Proposed") {
+  const fields = input.fields || {};
+  return [
+    `${verb} pull request draft.`,
+    "",
+    conversationSection("Title", fields.title),
+    "",
+    conversationSection("Body", fields.body)
+  ].join("\n");
+}
+
 function pullRequestInputInteraction(values = {}) {
   return {
     fields: [
@@ -1205,8 +1453,8 @@ function pullRequestInputInteraction(values = {}) {
     kind: "collect_input_run_command",
     prompt: "Review the pull request details. Save changes here, or continue to create the GitHub pull request.",
     submitKind: STEP_INPUT_KIND.CONFIRM_FILES,
-    submitLabel: "Update PR",
-    title: "Create pull request"
+    submitLabel: "Save draft",
+    title: "Create pull request, possibly merge"
   };
 }
 
@@ -1231,78 +1479,15 @@ const coreLifecycleSteps = Object.freeze([
     id: dependenciesInstalledStepId,
     machine: dependenciesInstalledMachine
   },
-  {
-    definition: coreLifecycleStepDefinitionsById[projectValidatedStepId],
-    id: projectValidatedStepId,
-    machine: projectValidatedMachine
-  },
   {
     definition: coreLifecycleStepDefinitionsById[changesCommittedStepId],
     id: changesCommittedStepId,
     machine: changesCommittedMachine
   },
   {
-    config: {
-      command: {
-        actionId: "create_pr_on_gh",
-        doneMetadata: "pr_url",
-        failureState: (context = {}) => machineState(STEP_STATUS.WAITING_FOR_INPUT, {
-          from: STEP_STATUS.ATTEMPTING_EXECUTION,
-          message: normalizeText(context.actionResult?.message),
-          output: normalizeText(context.actionResult?.output)
-        })
-      },
-      done: (session = {}) => metadataExists(session, "pr_url"),
-      draftOrigin: "prompt",
-      draftReady: pullRequestFilesAreReady,
-      interaction: (_status, values = {}) => pullRequestInputInteraction(values),
-      nextWhenConfirmed: {
-        disabledReason: "Create the pull request before continuing."
-      },
-      nextWhenDrafting: {
-        disabledReason: "Resolve the pull request content before continuing."
-      },
-      nextWhenWaitingForInput: {
-        disabledReason: "Resolve the pull request input request before continuing."
-      },
-      nextWhenWorking: {
-        disabledReason: "Create the pull request before continuing."
-      },
-      onWaitingActions: (context = {}) => disableAction(context.session, "create_pr_on_gh", "Resolve the pull request input request before retrying."),
-      promptInstruction() {
-        return currentStepHelperInstruction({
-          doneFields: {
-            body: "Markdown pull request body",
-            title: "Pull request title"
-          },
-          doneMeaning: "The pull request title and body are ready for user confirmation.",
-          waitingForInputMeaning: "You cannot draft the pull request without a user decision or missing repository context."
-        });
-      },
-      readValues: readPullRequestFieldValues,
-      saveValues: writePullRequestFieldValues,
-      unsupportedDoneMessage: "The pull request step cannot accept input right now.",
-      userResponseResumeStatus: (state = {}) => state.from === STEP_STATUS.ATTEMPTING_EXECUTION
-        ? STEP_STATUS.CONFIRM_FILES
-        : STEP_STATUS.AWAITING_AGENT_RESULT,
-      waitingInteraction: (state = {}) => commandFailureInteraction({
-        prompt: state.message || "Codex needs more information before the pull request can continue.",
-        title: "Pull request needs input"
-      })
-    },
-    definition: coreLifecycleStepDefinitionsById[createPullRequestStepId],
-    factoryId: "editable_artifact_review",
-    id: createPullRequestStepId
-  },
-  {
-    definition: coreLifecycleStepDefinitionsById[prMergedStepId],
-    id: prMergedStepId,
-    machine: pullRequestMergedMachine
-  },
-  {
-    definition: coreLifecycleStepDefinitionsById[mainCheckoutSyncedStepId],
-    id: mainCheckoutSyncedStepId,
-    machine: mainCheckoutSyncedMachine
+    definition: coreLifecycleStepDefinitionsById[createAndMergePullRequestStepId],
+    id: createAndMergePullRequestStepId,
+    machine: createAndMergePullRequestMachine
   },
   {
     definition: coreLifecycleStepDefinitionsById[sessionFinishedStepId],
@@ -1324,11 +1509,8 @@ const _testing = deepFreeze({
     workSourceSelectedStepId,
     worktreeCreatedStepId,
     dependenciesInstalledStepId,
-    projectValidatedStepId,
     changesCommittedStepId,
-    createPullRequestStepId,
-    prMergedStepId,
-    mainCheckoutSyncedStepId,
+    createAndMergePullRequestStepId,
     sessionFinishedStepId
   ]
 });