vibe64 0.1.21 → 0.1.22

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

@@ -16,16 +16,23 @@ import {
   REPORT_ARTIFACT
 } from "../workflowArtifacts.js";
 import {
-  buildAgentConversationActionDefinition,
-  buildAgentConversationStepDefinition
+  buildAgentConversationActionDefinition
 } from "../workflowDefinitionBuilders.js";
+import {
+  defineWorkflow,
+  workflowGroup,
+  workflowWhen
+} from "../workflowDefinitionComposers.js";
 import {
   coreLifecycleWorkflowIntentHandlers
 } from "./coreLifecycle.js";
 import { when } from "../workflowConditions.js";
 import {
+  LET_CODEX_DECIDE_INPUT,
   STEP_INPUT_KIND,
   STEP_STATUS,
+  actionCompleted,
+  assertAgentResultSource,
   artifactIsReady,
   artifactText,
   commandFailureInteraction,
@@ -45,6 +52,7 @@ import {
   readState,
   requireInputValue,
   unsupportedInputKind,
+  writePromptResponseArtifact,
   writeState
 } from "../workflowStepMachineHelpers.js";
 
@@ -52,27 +60,38 @@ const moduleId = "core.coding";
 
 const VIBE64_WORKFLOW_DEFINITION_IDS = deepFreeze({
   BIG_FEATURE: "big_feature",
-  GENERAL_CODING: "general_coding",
   SEED_APPLICATION: "seed_application"
 });
 const DEFAULT_VIBE64_WORKFLOW_DEFINITION_ID = VIBE64_WORKFLOW_DEFINITION_IDS.BIG_FEATURE;
+const CORE_CODING_WORKFLOW_GROUP_IDS = deepFreeze({
+  FINISH_OFF: "finish_off",
+  QA: "qa"
+});
 
-const agentConversationStepId = "agent_conversation";
 const changesAcceptedStepId = "changes_accepted";
 const deepUiCheckRunStepId = "deep_ui_check_run";
 const implementationReviewedStepId = "implementation_reviewed";
-const issueSubmittedStepId = "issue_submitted";
-const planExecutedStepId = "plan_executed";
-const planMadeStepId = "plan_made";
-const projectKnowledgeUpdatedStepId = "project_knowledge_updated";
-const reportCreatedStepId = "report_created";
-const reviewRunStepId = "review_run";
+const planAndExecuteStepId = "plan_and_execute";
+const reportAndKnowledgeUpdatedStepId = "report_and_update_knowledge";
+const reviewAndValidateStepId = "review_and_validate";
 const seedPlanExecutedStepId = "seed_plan_executed";
 const seedPlanMadeStepId = "seed_plan_made";
 const finalReviewConversationActionId = "final_review_conversation";
 const humanReviewConversationActionId = "human_review_conversation";
 const ISSUE_FILE_STEP_ID = "issue_file_created";
+const draftIssueActionId = "draft_issue";
+const rejectIssueDraftActionId = "reject_issue_draft";
 const SEED_APPLICATION_STEP_ID = "seed_application_defined";
+const GITHUB_ISSUE_MODE_METADATA = "github_issue_mode";
+const PLAN_READY_METADATA = "plan_ready";
+const IMPLEMENTATION_DONE_METADATA = "implementation_done";
+const PROJECT_KNOWLEDGE_UPDATED_METADATA = "project_knowledge_updated";
+const REVIEW_DESLOP_COMPLETED_METADATA = "review_deslop_completed";
+const GITHUB_ISSUE_MODES = deepFreeze({
+  CREATE: "create",
+  REUSE: "reuse",
+  SKIP: "skip"
+});
 
 async function skipOptionalCheck(ctx = {}) {
   return ctx.forceAdvance("Skipped optional check.");
@@ -95,18 +114,51 @@ const finalReviewIntentHandlers = deepFreeze({
 const optionalCheckIntentHandlers = deepFreeze({
   skip_optional_check: skipOptionalCheck
 });
-const coreCodingSeedWorkflowIntentHandlers = deepFreeze({
-  ...coreLifecycleWorkflowIntentHandlers,
-  [changesAcceptedStepId]: finalReviewIntentHandlers
-});
-const coreCodingStandardWorkflowIntentHandlers = deepFreeze({
-  ...coreCodingSeedWorkflowIntentHandlers,
-  [deepUiCheckRunStepId]: optionalCheckIntentHandlers
-});
+
+function finishOffWorkflowGroup({
+  recheckTo = "",
+  rejectTo = ""
+} = {}) {
+  return workflowGroup({
+    id: CORE_CODING_WORKFLOW_GROUP_IDS.FINISH_OFF,
+    intentHandlers: {
+      ...coreLifecycleWorkflowIntentHandlers,
+      [changesAcceptedStepId]: finalReviewIntentHandlers
+    },
+    steps: [
+      {
+        recheckTo,
+        rejectTo,
+        stepId: changesAcceptedStepId
+      },
+      reportAndKnowledgeUpdatedStepId,
+      "changes_committed",
+      "create_and_merge_pull_request",
+      "session_finished"
+    ]
+  });
+}
+
+function qaWorkflowGroup({
+  humanReview = true
+} = {}) {
+  return workflowGroup({
+    id: CORE_CODING_WORKFLOW_GROUP_IDS.QA,
+    intentHandlers: {
+      [deepUiCheckRunStepId]: optionalCheckIntentHandlers
+    },
+    steps: [
+      workflowWhen(humanReview, implementationReviewedStepId),
+      deepUiCheckRunStepId,
+      reviewAndValidateStepId
+    ]
+  });
+}
 
 function createIssueOnGithubAction() {
   return {
     adapterCapability: "create_issue_on_gh",
+    auditMessage: "Issue draft accepted; creating GitHub issue.",
     disabledReason: "Create the issue file before submitting it to GitHub.",
     disabledWhen: [when.metadataExists("issue_url")],
     disabledWhenReason: "The GitHub issue already exists.",
@@ -115,6 +167,7 @@ function createIssueOnGithubAction() {
     icon: "github",
     id: "create_issue_on_gh",
     label: "Create issue on GH",
+    saveCurrentStepInputBeforeRun: true,
     type: "command"
   };
 }
@@ -142,63 +195,103 @@ const coreCodingStepDefinitionsById = deepFreeze({
   [ISSUE_FILE_STEP_ID]: {
     actions: [
       {
-        adapterCapability: "use_existing_issue",
-        disabledReason: "An existing issue is already selected.",
+        disabledReason: "Work details are already saved.",
+        disabledWhen: [
+          when.allArtifactsReady(ISSUE_TITLE_ARTIFACT, ISSUE_BODY_ARTIFACT, ISSUE_WORD_ARTIFACT)
+        ],
+        icon: "message-square-plus",
+        id: draftIssueActionId,
+        inputFields: [
+          {
+            kind: "textarea",
+            label: "What do you want Vibe64 to work on?",
+            name: "conversationRequest",
+            placeholder: "Describe the feature, bug, or change you want.",
+            requiredMessage: "Describe what you want Vibe64 to work on."
+          }
+        ],
+        label: "Describe work",
+        promptId: draftIssueActionId,
+        recordsConversationTurn: true,
+        type: "prompt"
+      },
+      {
+        disabledReason: "Draft an issue before requesting improvements.",
         disabledWhen: [when.metadataExists("issue_url")],
-        icon: "github",
-        id: "use_existing_issue",
+        disabledWhenReason: "An existing issue is already selected.",
+        enabledWhen: [when.allArtifactsReady(ISSUE_TITLE_ARTIFACT, ISSUE_BODY_ARTIFACT, ISSUE_WORD_ARTIFACT)],
+        enabledWhenReason: "Draft an issue before requesting improvements.",
+        icon: "rotate-ccw",
+        id: rejectIssueDraftActionId,
         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."
+            kind: "textarea",
+            label: "What should change?",
+            name: "feedback",
+            placeholder: "Tell Codex how to improve the saved issue draft.",
+            requiredMessage: "Explain what should change before sending the improvement request."
           }
         ],
-        label: "Use existing issue",
-        type: "adapter"
-      }
+        label: "Send improvement request",
+        promptId: draftIssueActionId,
+        recordsConversationTurn: true,
+        type: "prompt"
+      },
+      createIssueOnGithubAction()
     ],
     autopilot: {
       kind: "issue_discussion",
       stop: true
     },
-    description: "Define a new issue or select an existing GitHub issue.",
+    description: "Define the work and create a GitHub issue only when the starting point requires one.",
     id: ISSUE_FILE_STEP_ID,
-    label: "Define or select issue",
+    label: "Define work",
     next: {
-      disabledReason: "Discuss and finalise issue before continuing.",
-      enabledWhen: [
-        when.any(
-          when.metadataExists("issue_url"),
-          when.allArtifactsReady(ISSUE_TITLE_ARTIFACT, ISSUE_BODY_ARTIFACT, ISSUE_WORD_ARTIFACT)
-        )
-      ]
-    },
-    rewindCleanup: {
-      actionResults: ["use_existing_issue"],
-      artifacts: [ISSUE_TITLE_ARTIFACT, ISSUE_BODY_ARTIFACT, ISSUE_WORD_ARTIFACT],
-      metadata: ["issue_url", "issue_number", "issue_title", "issue_source", ISSUE_WORD_ARTIFACT]
-    }
-  },
-  [issueSubmittedStepId]: {
-    actions: [
-      createIssueOnGithubAction()
-    ],
-    autopilot: {
-      actionId: "create_issue_on_gh",
-      completeWhen: [when.metadataExists("issue_url")],
-      label: "Edit and submit issue"
+      disabledReason: "Define the work before continuing.",
+      enabledWhen: [when.allArtifactsReady(ISSUE_TITLE_ARTIFACT, ISSUE_BODY_ARTIFACT, ISSUE_WORD_ARTIFACT)]
     },
-    description: "Review the issue files and submit the GitHub issue.",
-    id: issueSubmittedStepId,
-    label: "Edit and submit issue",
-    next: {
-      enabledWhen: [when.metadataExists("issue_url")]
+    presentation: {
+      stop: {
+        intents: [
+          {
+            actionId: draftIssueActionId,
+            id: draftIssueActionId,
+            label: "Describe work",
+            style: "primary",
+            type: "action"
+          },
+          {
+            actionId: "create_issue_on_gh",
+            id: "create_issue_on_gh",
+            label: "Create issue on GH",
+            style: "secondary",
+            type: "action"
+          }
+        ],
+        screen: {
+          kind: "issue_source",
+          message: "Describe the work, review the saved details, and create a GitHub issue only when this session requires one.",
+          primaryIntentId: draftIssueActionId,
+          title: "Define work"
+        }
+      }
     },
     rewindCleanup: {
-      actionResults: ["create_issue_on_gh"],
-      metadata: ["issue_url", "issue_number", "issue_title"]
+      actionResults: [draftIssueActionId, rejectIssueDraftActionId, "create_issue_on_gh"],
+      artifacts: [ISSUE_TITLE_ARTIFACT, ISSUE_BODY_ARTIFACT, ISSUE_WORD_ARTIFACT],
+      metadata: [
+        "issue_url",
+        "issue_number",
+        "issue_title",
+        "issue_source",
+        "work_anchor_number",
+        "work_anchor_title",
+        "work_anchor_type",
+        "work_anchor_url",
+        ISSUE_WORD_ARTIFACT,
+        PLAN_READY_METADATA,
+        IMPLEMENTATION_DONE_METADATA
+      ]
     }
   },
   [seedPlanMadeStepId]: {
@@ -241,29 +334,22 @@ const coreCodingStepDefinitionsById = deepFreeze({
       actionResults: ["execute_seed_plan"]
     }
   },
-  [planMadeStepId]: {
+  [planAndExecuteStepId]: {
     actions: [
       {
+        disabledWhen: [when.metadataExists(PLAN_READY_METADATA)],
+        disabledWhenReason: "The plan is already ready.",
         id: "make_plan",
-        label: "Make plan",
+        label: "Make a plan",
         promptId: "make_plan",
         type: "prompt"
-      }
-    ],
-    autopilot: {
-      actionId: "make_plan",
-      label: "Make plan"
-    },
-    description: "Ask Codex to create the implementation plan.",
-    id: planMadeStepId,
-    label: "Make plan",
-    rewindCleanup: {
-      actionResults: ["make_plan"]
-    }
-  },
-  [planExecutedStepId]: {
-    actions: [
+      },
       {
+        disabledReason: "Implementation is already complete.",
+        disabledWhen: [when.metadataExists(IMPLEMENTATION_DONE_METADATA)],
+        disabledWhenReason: "Implementation is already complete.",
+        enabledWhen: [when.metadataExists(PLAN_READY_METADATA)],
+        enabledWhenReason: "Make the plan before executing it.",
         id: "execute_plan",
         label: "Execute plan",
         promptId: "execute_plan",
@@ -271,14 +357,30 @@ const coreCodingStepDefinitionsById = deepFreeze({
       }
     ],
     autopilot: {
-      actionId: "execute_plan",
-      label: "Execute plan"
+      actionSequence: [
+        {
+          actionId: "make_plan",
+          completeWhen: [when.metadataExists(PLAN_READY_METADATA)],
+          label: "Make a plan"
+        },
+        {
+          actionId: "execute_plan",
+          completeWhen: [when.metadataExists(IMPLEMENTATION_DONE_METADATA)],
+          label: "Execute plan"
+        }
+      ],
+      label: "Plan and execute"
+    },
+    description: "Ask Codex to create the implementation plan, then execute it.",
+    id: planAndExecuteStepId,
+    label: "Plan and execute",
+    next: {
+      disabledReason: "Execute the plan before continuing.",
+      enabledWhen: [when.metadataExists(IMPLEMENTATION_DONE_METADATA)]
     },
-    description: "Ask Codex to execute the plan.",
-    id: planExecutedStepId,
-    label: "Execute plan",
     rewindCleanup: {
-      actionResults: ["execute_plan"]
+      actionResults: ["make_plan", "execute_plan"],
+      metadata: [PLAN_READY_METADATA, IMPLEMENTATION_DONE_METADATA]
     }
   },
   [implementationReviewedStepId]: {
@@ -297,7 +399,7 @@ const coreCodingStepDefinitionsById = deepFreeze({
     },
     description: "Try the implemented work and request small tweaks before slower review steps.",
     id: implementationReviewedStepId,
-    label: "Human review",
+    label: "Initial human review",
     presentation: {
       stop: {
         intents: [
@@ -325,11 +427,13 @@ const coreCodingStepDefinitionsById = deepFreeze({
             type: "action"
           }
         ],
+        persistWhenComplete: true,
         screen: {
           kind: "review",
           message: "Try the work now. Ask Codex for small tweaks, or continue when it looks right.",
           sections: ["launch_controls", "report_preview", "response_preview"],
-          title: "Human review",
+          title: "Initial human review",
+          primaryIntentId: "request_review_tweak",
           variant: "implementation"
         }
       }
@@ -339,32 +443,23 @@ const coreCodingStepDefinitionsById = deepFreeze({
       artifacts: [HUMAN_INPUT_RESPONSE_ARTIFACT]
     }
   },
-  [agentConversationStepId]: buildAgentConversationStepDefinition({
-    actionLabel: "Ask Codex for changes",
-    description: "Ask Codex to make focused code changes while you inspect and steer the work.",
-    id: agentConversationStepId,
-    inputLabel: "What should Codex change?",
-    inputPlaceholder: "Describe the code change, cleanup, bug fix, or follow-up request.",
-    label: "Make changes",
-    responseArtifact: HUMAN_INPUT_RESPONSE_ARTIFACT
-  }),
   [deepUiCheckRunStepId]: {
     actions: [
       {
         id: "run_deep_ui_check",
-        label: "Run deep UI check",
+        label: "Check user interface",
         promptId: "run_deep_ui_check",
         type: "prompt"
       }
     ],
     autopilot: {
       actionId: "run_deep_ui_check",
-      label: "Run deep UI check",
+      label: "Check user interface",
       userDecision: true
     },
     description: "Run the deeper UI review when the target supports it.",
     id: deepUiCheckRunStepId,
-    label: "Run deep UI check",
+    label: "Check user interface",
     presentation: {
       decision: {
         intents: [
@@ -392,24 +487,78 @@ const coreCodingStepDefinitionsById = deepFreeze({
       actionResults: ["run_deep_ui_check"]
     }
   },
-  [reviewRunStepId]: {
+  [reviewAndValidateStepId]: {
     actions: [
       {
         id: "run_deslop",
         label: "Run deslop",
         promptId: "run_deslop",
         type: "prompt"
+      },
+      {
+        adapterCapability: "update_code_index",
+        enabledWhen: [when.metadataExists(REVIEW_DESLOP_COMPLETED_METADATA)],
+        enabledWhenReason: "Run review/deslop before updating the code index.",
+        icon: "sync",
+        id: "update_code_index",
+        label: "Update code index",
+        type: "command"
+      },
+      {
+        adapterCapability: "run_automated_checks",
+        enabledWhen: [
+          when.metadataExists(REVIEW_DESLOP_COMPLETED_METADATA),
+          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: {
-      actionId: "run_deslop",
-      label: "Run deslop"
+      actionSequence: [
+        {
+          actionId: "run_deslop",
+          completeWhen: [when.metadataExists(REVIEW_DESLOP_COMPLETED_METADATA)],
+          label: "Run review/deslop"
+        },
+        {
+          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: "Review and validate"
+    },
+    description: "Run review/deslop, update the code index, and run automated checks.",
+    id: reviewAndValidateStepId,
+    label: "Review and validate",
+    next: {
+      disabledReason: "Run review/deslop, update the code index, and run automated checks successfully before continuing.",
+      enabledWhen: [
+        when.metadataExists(REVIEW_DESLOP_COMPLETED_METADATA),
+        when.metadataExists("code_index_updated"),
+        when.metadataExists("automated_checks_passed")
+      ]
     },
-    description: "Run the review/deslop prompt.",
-    id: reviewRunStepId,
-    label: "Run review/deslop",
     rewindCleanup: {
-      actionResults: ["run_deslop"]
+      actionResults: ["run_deslop", "update_code_index", "run_automated_checks"],
+      metadata: [
+        REVIEW_DESLOP_COMPLETED_METADATA,
+        "code_index_command_source",
+        "code_index_package_manager",
+        "code_index_path",
+        "code_index_updated",
+        "automated_checks_package_manager",
+        "automated_checks_passed"
+      ]
     }
   },
   [changesAcceptedStepId]: {
@@ -428,7 +577,7 @@ const coreCodingStepDefinitionsById = deepFreeze({
     },
     description: "Review the validated work before the report, commit, and pull request.",
     id: changesAcceptedStepId,
-    label: "Final review",
+    label: "Final human review",
     presentation: {
       automation: {
         recheckAfterPrompt: {
@@ -479,11 +628,13 @@ const coreCodingStepDefinitionsById = deepFreeze({
             type: "reject"
           }
         ],
+        persistWhenComplete: true,
         screen: {
           kind: "review",
           message: "Review the validated work before Autopilot writes the report and commits.",
           sections: ["launch_controls", "report_preview", "response_preview"],
-          title: "Final review",
+          title: "Final human review",
+          primaryIntentId: "request_review_tweak",
           variant: "final"
         }
       }
@@ -493,35 +644,17 @@ const coreCodingStepDefinitionsById = deepFreeze({
       metadata: ["autopilot_final_review_followup"]
     }
   },
-  [reportCreatedStepId]: {
+  [reportAndKnowledgeUpdatedStepId]: {
     actions: [
       {
         id: "write_report",
         label: "Write report",
         promptId: "write_report",
         type: "prompt"
-      }
-    ],
-    autopilot: {
-      actionId: "write_report",
-      completeWhen: [when.artifactReady(REPORT_ARTIFACT)],
-      label: "Write report"
-    },
-    description: "Write the local report explaining what changed and why.",
-    id: reportCreatedStepId,
-    label: "Write report",
-    next: {
-      disabledReason: "Write the session report before updating project knowledge.",
-      enabledWhen: [when.artifactReady(REPORT_ARTIFACT)]
-    },
-    rewindCleanup: {
-      actionResults: ["write_report"],
-      artifacts: [REPORT_ARTIFACT]
-    }
-  },
-  [projectKnowledgeUpdatedStepId]: {
-    actions: [
+      },
       {
+        enabledWhen: [when.artifactReady(REPORT_ARTIFACT)],
+        enabledWhenReason: "Write the session report before updating project knowledge.",
         id: "update_project_knowledge",
         label: "Update project knowledge",
         promptId: "update_project_knowledge",
@@ -529,26 +662,44 @@ const coreCodingStepDefinitionsById = deepFreeze({
       }
     ],
     autopilot: {
-      actionId: "update_project_knowledge",
-      label: "Update project knowledge"
+      actionSequence: [
+        {
+          actionId: "write_report",
+          completeWhen: [when.artifactReady(REPORT_ARTIFACT)],
+          label: "Write report"
+        },
+        {
+          actionId: "update_project_knowledge",
+          completeWhen: [when.metadataExists(PROJECT_KNOWLEDGE_UPDATED_METADATA)],
+          label: "Update project knowledge"
+        }
+      ],
+      label: "Write report and update project knowledge"
+    },
+    description: "Write the local report and update adapter-supported project knowledge.",
+    id: reportAndKnowledgeUpdatedStepId,
+    label: "Write report and update project knowledge",
+    next: {
+      disabledReason: "Write the report and update project knowledge before continuing.",
+      enabledWhen: [
+        when.artifactReady(REPORT_ARTIFACT),
+        when.metadataExists(PROJECT_KNOWLEDGE_UPDATED_METADATA)
+      ]
     },
-    description: "Update adapter-supported project knowledge.",
-    id: projectKnowledgeUpdatedStepId,
-    label: "Update project knowledge",
     rewindCleanup: {
-      actionResults: ["update_project_knowledge"]
+      actionResults: ["write_report", "update_project_knowledge"],
+      artifacts: [REPORT_ARTIFACT],
+      metadata: [PROJECT_KNOWLEDGE_UPDATED_METADATA]
     }
   }
 });
 
 const coreCodingWorkflowDefinitions = deepFreeze([
-  {
+  defineWorkflow({
     description: "Create the initial application scaffold and local development foundation.",
     id: VIBE64_WORKFLOW_DEFINITION_IDS.SEED_APPLICATION,
-    intentHandlers: coreCodingSeedWorkflowIntentHandlers,
     label: "Seed application",
-    sessionWord: "seeding",
-    steps: [
+    parts: [
       "session_created",
       "work_source_selected",
       "worktree_created",
@@ -556,85 +707,36 @@ const coreCodingWorkflowDefinitions = deepFreeze([
       seedPlanMadeStepId,
       seedPlanExecutedStepId,
       "dependencies_installed",
-      "project_validated",
-      {
+      reviewAndValidateStepId,
+      finishOffWorkflowGroup({
         rejectTo: seedPlanMadeStepId,
-        recheckTo: "project_validated",
-        stepId: changesAcceptedStepId
-      },
-      reportCreatedStepId,
-      projectKnowledgeUpdatedStepId,
-      "changes_committed",
-      "create_pull_request",
-      "pr_merged",
-      "main_checkout_synced",
-      "session_finished"
+        recheckTo: reviewAndValidateStepId
+      })
     ],
+    sessionWord: "seeding",
     userSelectable: false
-  },
-  {
-    description: "Plan, implement, review, validate, commit, create a PR, and optionally merge.",
+  }),
+  defineWorkflow({
+    description: "Define, plan, implement, review, validate, commit, create a PR, and optionally merge.",
     id: VIBE64_WORKFLOW_DEFINITION_IDS.BIG_FEATURE,
-    intentHandlers: coreCodingStandardWorkflowIntentHandlers,
-    label: "Big feature",
-    steps: [
+    label: "Make improvements",
+    parts: [
       "session_created",
       "work_source_selected",
       "worktree_created",
       "dependencies_installed",
       ISSUE_FILE_STEP_ID,
-      issueSubmittedStepId,
-      planMadeStepId,
-      planExecutedStepId,
-      implementationReviewedStepId,
-      deepUiCheckRunStepId,
-      reviewRunStepId,
-      "project_validated",
-      {
-        rejectTo: planMadeStepId,
-        recheckTo: reviewRunStepId,
-        stepId: changesAcceptedStepId
-      },
-      reportCreatedStepId,
-      projectKnowledgeUpdatedStepId,
-      "changes_committed",
-      "create_pull_request",
-      "pr_merged",
-      "main_checkout_synced",
-      "session_finished"
-    ],
-    userSelectable: true
-  },
-  {
-    description: "Make focused code changes with Codex, review, validate, commit, create a PR, and optionally merge.",
-    id: VIBE64_WORKFLOW_DEFINITION_IDS.GENERAL_CODING,
-    intentHandlers: coreCodingStandardWorkflowIntentHandlers,
-    label: "General coding",
-    sessionWord: "coding",
-    steps: [
-      "session_created",
-      "work_source_selected",
-      "worktree_created",
-      "dependencies_installed",
-      agentConversationStepId,
-      deepUiCheckRunStepId,
-      reviewRunStepId,
-      "project_validated",
-      {
-        rejectTo: agentConversationStepId,
-        recheckTo: reviewRunStepId,
-        stepId: changesAcceptedStepId
-      },
-      reportCreatedStepId,
-      projectKnowledgeUpdatedStepId,
-      "changes_committed",
-      "create_pull_request",
-      "pr_merged",
-      "main_checkout_synced",
-      "session_finished"
+      planAndExecuteStepId,
+      qaWorkflowGroup({
+        humanReview: true
+      }),
+      finishOffWorkflowGroup({
+        rejectTo: planAndExecuteStepId,
+        recheckTo: reviewAndValidateStepId
+      })
     ],
     userSelectable: true
-  }
+  })
 ]);
 
 function issueFilesAreReady(session = {}) {
@@ -645,6 +747,70 @@ function issueFilesAreReady(session = {}) {
   ].every((artifactName) => artifactIsReady(session, artifactName));
 }
 
+function githubIssueMode(session = {}) {
+  return normalizeText(session.metadata?.[GITHUB_ISSUE_MODE_METADATA]);
+}
+
+function githubIssueShouldBeCreated(session = {}) {
+  return githubIssueMode(session) === GITHUB_ISSUE_MODES.CREATE;
+}
+
+function githubIssueShouldBeSkipped(session = {}) {
+  return githubIssueMode(session) === GITHUB_ISSUE_MODES.SKIP;
+}
+
+function githubIssueIsReused(session = {}) {
+  return githubIssueMode(session) === GITHUB_ISSUE_MODES.REUSE;
+}
+
+function disableActions(session = {}, reasonsById = {}) {
+  const reasons = Object.entries(reasonsById)
+    .filter(([, reason]) => normalizeText(reason));
+  if (reasons.length === 0) {
+    return Array.isArray(session.actions) ? session.actions : [];
+  }
+  return (Array.isArray(session.actions) ? session.actions : []).map((action) => {
+    const reasonEntry = reasons.find(([id]) => action.id === id);
+    if (!reasonEntry) {
+      return action;
+    }
+    return {
+      ...action,
+      disabledReason: reasonEntry[1],
+      enabled: false
+    };
+  });
+}
+
+function inputResponseText(input = {}) {
+  return normalizeText(input.text || input.fields?.response || input.fields?.conversationRequest);
+}
+
+function conversationSection(label = "", value = "") {
+  const normalizedValue = normalizeText(value);
+  return [
+    `${label}:`,
+    normalizedValue || "(empty)"
+  ].join("\n");
+}
+
+function issueDraftConversationMessage(context = {}, input = {}, {
+  proposed = false
+} = {}) {
+  const fields = input?.fields || {};
+  const createGithubIssue = githubIssueShouldBeCreated(context.session);
+  const subject = createGithubIssue ? "issue draft" : "work description";
+  return [
+    `${proposed ? "Proposed" : "Saved"} ${subject}.`,
+    "",
+    conversationSection(createGithubIssue ? "Issue title" : "Work title", fields.title),
+    "",
+    conversationSection("Session label", fields.word),
+    "",
+    conversationSection(createGithubIssue ? "Issue body" : "Work description", fields.body)
+  ].join("\n");
+}
+
 async function readIssueFieldValues(context = {}) {
   const [title, body, word] = await Promise.all([
     context.runtime.store.readArtifact(context.session.sessionId, ISSUE_TITLE_ARTIFACT),
@@ -659,28 +825,76 @@ async function readIssueFieldValues(context = {}) {
 }
 
 async function writeIssueFieldValues(context = {}, fields = {}) {
-  const title = requireInputValue(fields.title, "Issue title is required.");
-  const body = requireInputValue(fields.body, "Issue body is required.");
+  const title = requireInputValue(fields.title, "Work title is required.");
+  const body = requireInputValue(fields.body, "Work description is required.");
   const word = requireInputValue(fields.word, "Session label is required.");
+  const mode = githubIssueMode(context.session);
+  const preservesExistingPrAnchor = mode === GITHUB_ISSUE_MODES.SKIP &&
+    normalizeText(context.session.metadata?.work_source) === "existing_pr";
+  const staleMetadata = preservesExistingPrAnchor
+    ? ["issue_number", "issue_url"]
+    : ["issue_number", "issue_url", "work_anchor_number", "work_anchor_url"];
+  const metadata = {
+    issue_title: title,
+    ...(preservesExistingPrAnchor ? {} : { work_anchor_title: title }),
+    ...(mode === GITHUB_ISSUE_MODES.SKIP
+      ? {
+          issue_source: "none",
+          ...(preservesExistingPrAnchor ? {} : { work_anchor_type: "description" })
+        }
+      : {
+          issue_source: "draft",
+          work_anchor_type: "issue"
+        })
+  };
 
   await Promise.all([
     context.runtime.store.writeArtifact(context.session.sessionId, ISSUE_TITLE_ARTIFACT, artifactText(title)),
     context.runtime.store.writeArtifact(context.session.sessionId, ISSUE_BODY_ARTIFACT, artifactText(body)),
     context.runtime.store.writeArtifact(context.session.sessionId, ISSUE_WORD_ARTIFACT, artifactText(word)),
-    context.runtime.store.writeMetadataValue(context.session.sessionId, "issue_title", title),
-    context.runtime.store.writeIssueWordMetadata(context.session.sessionId, word)
+    ...Object.entries(metadata).map(([name, value]) => context.runtime.store.writeMetadataValue(
+      context.session.sessionId,
+      name,
+      value
+    )),
+    context.runtime.store.writeIssueWordMetadata(context.session.sessionId, word),
+    context.runtime.store.deleteMetadataValues(context.session.sessionId, staleMetadata)
   ]);
 }
 
-function issueInputInteraction(status = STEP_STATUS.WAITING_FOR_INPUT, values = {}) {
+function issueInputInteraction(status = STEP_STATUS.WAITING_FOR_INPUT, values = {}, {
+  createGithubIssue = false
+} = {}) {
+  const reviewIntents = status === STEP_STATUS.CONFIRM_FILES
+    ? [
+        {
+          id: "continue_step",
+          label: createGithubIssue ? "Create GitHub issue" : "Use this description",
+          auditMessage: createGithubIssue
+            ? "Issue draft accepted; creating GitHub issue."
+            : "Work description accepted.",
+          saveCurrentStepInputBeforeRun: true,
+          style: "primary",
+          type: createGithubIssue ? "action" : "continue",
+          ...(createGithubIssue ? { actionId: "create_issue_on_gh" } : {})
+        },
+        {
+          actionId: rejectIssueDraftActionId,
+          id: rejectIssueDraftActionId,
+          label: "Send improvement request",
+          style: "secondary",
+          type: "action"
+        }
+      ]
+    : [];
   return {
     fields: [
       {
         kind: "text",
-        label: "Issue title",
+        label: createGithubIssue ? "Issue title" : "Work title",
         name: "title",
         required: true,
-        requiredMessage: "Issue title is required.",
+        requiredMessage: createGithubIssue ? "Issue title is required." : "Work title is required.",
         value: values.title || ""
       },
       {
@@ -693,155 +907,402 @@ function issueInputInteraction(status = STEP_STATUS.WAITING_FOR_INPUT, values =
       },
       {
         kind: "textarea",
-        label: "Issue body",
+        label: createGithubIssue ? "Issue body" : "Work description",
         name: "body",
         required: true,
-        requiredMessage: "Issue body is required.",
+        requiredMessage: createGithubIssue ? "Issue body is required." : "Work description is required.",
         value: values.body || ""
       }
     ],
     kind: "confirm_files_run_command",
+    intents: reviewIntents,
     prompt: status === STEP_STATUS.CONFIRM_FILES
-      ? "Review the issue details. Save changes here, or continue to create the GitHub issue."
-      : "Discuss the requested change, then submit the issue title, session label, and issue body.",
+      ? (createGithubIssue
+          ? "Review the issue details, then create the GitHub issue."
+          : "Review the work details, then continue without creating a GitHub issue.")
+      : (createGithubIssue
+          ? "Discuss the requested change, then submit the issue title, session label, and issue body."
+          : "Discuss the requested change, then submit the work title, session label, and description."),
     submitKind: status === STEP_STATUS.CONFIRM_FILES
       ? STEP_INPUT_KIND.CONFIRM_FILES
       : STEP_INPUT_KIND.READY,
-    submitLabel: status === STEP_STATUS.CONFIRM_FILES ? "Update issue" : "Save issue",
-    title: "Define issue"
+    submitLabel: status === STEP_STATUS.CONFIRM_FILES ? "Save changes" : "Save details",
+    title: createGithubIssue ? "Define issue" : "Define work"
   };
 }
 
-const issueSubmittedMachine = {
-  stepId: issueSubmittedStepId,
+const issueFilePhase = Object.freeze({
+  CHOOSE_SOURCE: "choose_source",
+  CREATING_ISSUE: "creating_issue",
+  DRAFTING: "drafting",
+  EXISTING_SELECTED: "existing_selected",
+  REVIEW_DRAFT: "review_draft",
+  SKIPPED: "skipped"
+});
+
+function issueSkipMessage(session = {}) {
+  return normalizeText(session.metadata?.work_source) === "existing_pr"
+    ? "Skipped: existing PR selected as the work anchor; no GitHub issue is required."
+    : "No GitHub issue is required for this session.";
+}
+
+function issueSkipState(session = {}) {
+  return machineState(STEP_STATUS.DONE, {
+    message: issueSkipMessage(session),
+    phase: issueFilePhase.SKIPPED,
+    skipReason: issueSkipMessage(session)
+  });
+}
+
+function issueSourceSelectionState(details = {}) {
+  return machineState(STEP_STATUS.READY, {
+    phase: issueFilePhase.CHOOSE_SOURCE,
+    ...details
+  });
+}
+
+function issueDraftReviewState(details = {}) {
+  return machineState(STEP_STATUS.CONFIRM_FILES, {
+    phase: issueFilePhase.REVIEW_DRAFT,
+    ...details
+  });
+}
+
+function issueDraftPromptIsActive(state = {}) {
+  return [
+    STEP_STATUS.ATTEMPTING_EXECUTION,
+    STEP_STATUS.AWAITING_AGENT_RESULT,
+    STEP_STATUS.WAITING_FOR_INPUT
+  ].includes(state.status);
+}
+
+function workflowActionEnabled(session = {}, actionId = "") {
+  const normalizedActionId = normalizeText(actionId);
+  return Boolean((Array.isArray(session.actions) ? session.actions : [])
+    .find((action) => action.id === normalizedActionId)?.enabled);
+}
+
+function issueDraftResponseActionId(context = {}, state = {}) {
+  const stateActionId = normalizeText(state.promptActionId);
+  if (stateActionId) {
+    return stateActionId;
+  }
+  return workflowActionEnabled(context.session, rejectIssueDraftActionId)
+    ? rejectIssueDraftActionId
+    : draftIssueActionId;
+}
+
+async function submitIssueDraftAgentResult(context = {}, machine = {}, input = {}) {
+  assertAgentResultSource(context.session, input);
+  const state = await readState(context, machine);
+  const promptActionId = issueDraftResponseActionId(context, state);
+  switch (input.kind) {
+    case STEP_INPUT_KIND.WAITING_FOR_INPUT:
+      await writeState(context, machine, machineState(STEP_STATUS.WAITING_FOR_INPUT, {
+        message: input.message,
+        phase: issueFilePhase.DRAFTING,
+        promptActionId,
+        response: inputResponseText(input),
+        source: input.source
+      }));
+      return;
+
+    case STEP_INPUT_KIND.CONFIRM_FILES:
+    case STEP_INPUT_KIND.READY:
+      await writeIssueFieldValues(context, input.fields);
+      await writeState(context, machine, issueDraftReviewState({
+        response: inputResponseText(input),
+        source: input.source
+      }));
+      return;
+
+    default:
+      throw unsupportedInputKind(input.kind, machine.stepId);
+  }
+}
+
+const issueFileMachine = {
+  promptActionId: draftIssueActionId,
+  stepId: ISSUE_FILE_STEP_ID,
 
   initialState(context = {}) {
-    if (metadataExists(context.session, "issue_url")) {
-      return machineState(STEP_STATUS.DONE);
+    const filesReady = issueFilesAreReady(context.session);
+    if (githubIssueShouldBeSkipped(context.session) && filesReady) {
+      return issueSkipState(context.session);
     }
-    return issueFilesAreReady(context.session)
-      ? machineState(STEP_STATUS.READY)
-      : machineState(STEP_STATUS.WAITING_FOR_INPUT, {
-          message: "Define and save the issue before creating it on GitHub."
-        });
+    if ((githubIssueIsReused(context.session) || githubIssueShouldBeCreated(context.session)) && filesReady && metadataExists(context.session, "issue_url")) {
+      return machineState(STEP_STATUS.DONE, {
+        phase: issueFilePhase.EXISTING_SELECTED
+      });
+    }
+    return filesReady
+      ? issueDraftReviewState()
+      : issueSourceSelectionState();
   },
 
   async view(context = {}) {
     let state = await readState(context, this);
-    if (metadataExists(context.session, "issue_url")) {
-      state = machineState(STEP_STATUS.DONE);
-    } else if (issueFilesAreReady(context.session) && state.status === STEP_STATUS.WAITING_FOR_INPUT && state.from !== STEP_STATUS.ATTEMPTING_EXECUTION) {
-      state = machineState(STEP_STATUS.READY);
+    const filesReady = issueFilesAreReady(context.session);
+    const createGithubIssue = githubIssueShouldBeCreated(context.session);
+    const skipGithubIssue = githubIssueShouldBeSkipped(context.session);
+    if (skipGithubIssue && filesReady && state.status !== STEP_STATUS.CONFIRM_FILES && !issueDraftPromptIsActive(state)) {
+      state = issueSkipState(context.session);
+    } else if ((githubIssueIsReused(context.session) || createGithubIssue) && filesReady && metadataExists(context.session, "issue_url")) {
+      state = machineState(STEP_STATUS.DONE, {
+        phase: issueFilePhase.EXISTING_SELECTED
+      });
+    } else if (filesReady && state.status !== STEP_STATUS.CONFIRM_FILES && !issueDraftPromptIsActive(state)) {
+      state = issueDraftReviewState({
+        from: state.status
+      });
+    } else if (state.status === STEP_STATUS.DONE) {
+      state = issueSourceSelectionState({
+        from: STEP_STATUS.DONE,
+        message: "Issue details are incomplete. Select the issue again or draft a new one."
+      });
     }
 
     switch (state.status) {
-      case STEP_STATUS.DONE:
+      case STEP_STATUS.READY:
         return {
-          actions: disableAction(context.session, "create_issue_on_gh", "The GitHub issue already exists."),
+          actions: disableActions(context.session, {
+            create_issue_on_gh: createGithubIssue
+              ? "Save the issue details before creating the GitHub issue."
+              : "This session continues without creating a GitHub issue.",
+            [rejectIssueDraftActionId]: "Describe the work before requesting improvements."
+          }),
           next: nextForSession(context.session, {
-            enabled: true
+            disabledReason: "Describe the work before continuing."
           }),
-          stepMachine: publicState(this, state)
+          stepMachine: publicState(this, {
+            ...state,
+            message: state.message || "Describe the work before continuing."
+          })
         };
 
+      case STEP_STATUS.ATTEMPTING_EXECUTION:
+        return promptStepWaitingView(context, this, state, "Wait for Vibe64 to create the GitHub issue.");
+
+      case STEP_STATUS.AWAITING_AGENT_RESULT:
+        return promptStepWaitingView(context, this, state, "Wait for Codex to draft the work details.");
+
       case STEP_STATUS.WAITING_FOR_INPUT:
+        if (state.phase === issueFilePhase.CREATING_ISSUE) {
+          return {
+            actions: disableAction(context.session, "create_issue_on_gh", "Resolve the issue command before retrying."),
+            interaction: commandFailureInteraction({
+              prompt: state.message || "Could not create the GitHub issue. Explain what should happen, then retry.",
+              title: "Issue command needs attention"
+            }),
+            next: nextForSession(context.session, {
+              disabledReason: "Resolve the issue command before continuing."
+            }),
+            stepMachine: publicState(this, state)
+          };
+        }
+        return promptStepWaitingForInputView(context, this, state, {
+          actionId: issueDraftResponseActionId(context, state),
+          prompt: state.message || "Codex needs more information before it can draft the issue.",
+          skipInput: LET_CODEX_DECIDE_INPUT,
+          title: "Describe the issue"
+        });
+
+      case STEP_STATUS.CONFIRM_FILES: {
+        const values = await readIssueFieldValues(context);
         return {
-          actions: disableAction(context.session, "create_issue_on_gh", "Resolve the issue command failure before retrying."),
-          interaction: commandFailureInteraction({
-            prompt: state.message || "The GitHub issue command failed. Explain what should happen, then retry the command.",
-            title: "Issue command needs attention"
+          actions: skipGithubIssue
+            ? disableAction(context.session, "create_issue_on_gh", "This session continues without creating a GitHub issue.")
+            : context.session.actions,
+          interaction: issueInputInteraction(STEP_STATUS.CONFIRM_FILES, values, {
+            createGithubIssue
           }),
           next: nextForSession(context.session, {
-            disabledReason: "Resolve the GitHub issue command failure before continuing."
+            disabledReason: createGithubIssue ? "Create the GitHub issue before continuing." : "",
+            enabled: !createGithubIssue
           }),
-          stepMachine: publicState(this, state)
+          stepMachine: publicState(this, {
+            ...state,
+            message: state.message || (createGithubIssue ? "Review the saved issue draft." : "Review the saved work description.")
+          })
         };
+      }
 
-      case STEP_STATUS.READY:
-      case STEP_STATUS.ATTEMPTING_EXECUTION:
-      case STEP_STATUS.FAILED:
-      default:
+      case STEP_STATUS.DONE:
         return {
+          actions: disableActions(context.session, {
+            create_issue_on_gh: state.skipReason || "The GitHub issue state is already resolved.",
+            [draftIssueActionId]: state.skipReason || "Work details are already saved.",
+            [rejectIssueDraftActionId]: state.skipReason || "Work details are already saved."
+          }),
           next: nextForSession(context.session, {
-            disabledReason: "Create the GitHub issue before continuing."
+            enabled: true
           }),
-          stepMachine: publicState(this, state)
+          stepMachine: publicState(this, {
+            ...state,
+            message: state.message || "Work details are ready."
+          })
         };
-    }
-  },
 
-  async submitInput(context = {}) {
-    const state = await readState(context, this);
-    const input = normalizeMachineInput(context.input);
-    switch (state.status) {
-      case STEP_STATUS.WAITING_FOR_INPUT:
       case STEP_STATUS.FAILED:
-        if (input.kind === STEP_INPUT_KIND.CONSIDER_RESOLVED || input.kind === STEP_INPUT_KIND.USER_RESPONSE) {
-          await writeState(context, this, machineState(STEP_STATUS.READY, {
-            response: input.text || input.fields.response,
-            source: input.source
-          }));
-          return;
-        }
-        throw unsupportedInputKind(input.kind, this.stepId);
+        return {
+          next: nextForSession(context.session, {
+            disabledReason: "Resolve the work definition failure before continuing."
+          }),
+          stepMachine: publicState(this, {
+            ...state,
+            message: state.message || "Work definition failed."
+          })
+        };
 
-      case STEP_STATUS.READY:
-      case STEP_STATUS.ATTEMPTING_EXECUTION:
-      case STEP_STATUS.DONE:
       default:
-        throw vibe64Error("The GitHub issue step cannot accept input right now.", "vibe64_step_input_not_available");
+        return {
+          next: nextForSession(context.session, {
+            disabledReason: "Describe the work before continuing."
+          }),
+          stepMachine: publicState(this, state)
+        };
     }
   },
 
   async actionStarted(context = {}) {
-    if (context.actionId !== "create_issue_on_gh") {
+    if (context.actionId === draftIssueActionId) {
+      await writeState(context, this, machineState(STEP_STATUS.AWAITING_AGENT_RESULT, {
+        phase: issueFilePhase.DRAFTING,
+        promptActionId: context.actionId
+      }));
       return;
     }
 
-    const state = await readState(context, this);
-    switch (state.status) {
-      case STEP_STATUS.READY:
-      case STEP_STATUS.FAILED:
-        await writeState(context, this, machineState(STEP_STATUS.ATTEMPTING_EXECUTION));
-        return;
+    if (context.actionId === "create_issue_on_gh") {
+      await writeState(context, this, machineState(STEP_STATUS.ATTEMPTING_EXECUTION, {
+        phase: issueFilePhase.CREATING_ISSUE
+      }));
+      return;
+    }
 
-      case STEP_STATUS.ATTEMPTING_EXECUTION:
-      case STEP_STATUS.DONE:
-      default:
-        return;
+    if (context.actionId === rejectIssueDraftActionId) {
+      await writeState(context, this, machineState(STEP_STATUS.AWAITING_AGENT_RESULT, {
+        phase: issueFilePhase.DRAFTING,
+        promptActionId: context.actionId
+      }));
     }
   },
 
   async actionFinished(context = {}) {
-    if (context.actionId !== "create_issue_on_gh") {
+    if (context.actionId === "create_issue_on_gh") {
+      if (await commandSucceeded(context, "issue_url")) {
+        await writeState(context, this, machineState(STEP_STATUS.DONE, {
+          phase: issueFilePhase.EXISTING_SELECTED
+        }));
+        return;
+      }
+      await writeState(context, this, machineState(STEP_STATUS.WAITING_FOR_INPUT, {
+        from: STEP_STATUS.ATTEMPTING_EXECUTION,
+        message: normalizeText(context.actionResult?.message) || "Could not create the GitHub issue.",
+        output: normalizeText(context.actionResult?.output),
+        phase: issueFilePhase.CREATING_ISSUE
+      }));
       return;
     }
+  },
 
+  async submitInput(context = {}) {
     const state = await readState(context, this);
+    const input = normalizeMachineInput(context.input);
+
     switch (state.status) {
-      case STEP_STATUS.ATTEMPTING_EXECUTION:
       case STEP_STATUS.READY:
+        if (input.kind === STEP_INPUT_KIND.CONFIRM_FILES || input.kind === STEP_INPUT_KIND.READY) {
+          await writeIssueFieldValues(context, input.fields);
+          await writeState(context, this, issueDraftReviewState({
+            response: inputResponseText(input),
+            source: input.source
+          }));
+          return;
+        }
+        throw unsupportedInputKind(input.kind, this.stepId);
+
+      case STEP_STATUS.AWAITING_AGENT_RESULT:
+        await submitIssueDraftAgentResult(context, this, input);
+        return;
+
       case STEP_STATUS.WAITING_FOR_INPUT:
+        if (state.phase === issueFilePhase.CREATING_ISSUE && (input.kind === STEP_INPUT_KIND.CONSIDER_RESOLVED || input.kind === STEP_INPUT_KIND.USER_RESPONSE)) {
+          await writeState(context, this, issueDraftReviewState({
+            message: input.message,
+            response: inputResponseText(input),
+            source: input.source
+          }));
+          return;
+        }
+        if (input.source === "codex") {
+          await submitIssueDraftAgentResult(context, this, input);
+          return;
+        }
+        throw unsupportedInputKind(input.kind, this.stepId);
+
+      case STEP_STATUS.CONFIRM_FILES:
+        if (input.kind === STEP_INPUT_KIND.CONFIRM_FILES || input.kind === STEP_INPUT_KIND.READY) {
+          await writeIssueFieldValues(context, input.fields);
+          await writeState(context, this, githubIssueShouldBeSkipped(context.session)
+            ? issueSkipState(context.session)
+            : issueDraftReviewState({
+                response: inputResponseText(input),
+                source: input.source
+              }));
+          return;
+        }
+        throw unsupportedInputKind(input.kind, this.stepId);
+
       case STEP_STATUS.FAILED:
-        await writeState(context, this, await commandSucceeded(context, "issue_url")
-          ? 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)
-            }));
-        return;
+        if (input.kind === STEP_INPUT_KIND.CONSIDER_RESOLVED || input.kind === STEP_INPUT_KIND.USER_RESPONSE) {
+          await writeState(context, this, issueSourceSelectionState({
+            message: input.message,
+            response: inputResponseText(input),
+            source: input.source
+          }));
+          return;
+        }
+        throw unsupportedInputKind(input.kind, this.stepId);
 
       case STEP_STATUS.DONE:
       default:
-        return;
+        throw vibe64Error("The issue step is already complete.", "vibe64_step_input_not_available");
+    }
+  },
+
+  inputCompletionMessage(context = {}) {
+    const input = normalizeMachineInput(context.input);
+    if (![STEP_INPUT_KIND.READY, STEP_INPUT_KIND.CONFIRM_FILES].includes(input.kind)) {
+      return "";
     }
+    if (input.source === "codex") {
+      return issueDraftConversationMessage(context, input, { proposed: true });
+    }
+    if (input.source === "ui") {
+      return issueDraftConversationMessage(context, input);
+    }
+    return githubIssueShouldBeSkipped(context.session)
+      ? "Work description saved."
+      : "Issue draft submitted for review.";
+  },
+
+  promptInstruction() {
+    return currentStepHelperInstruction({
+      doneFields: {
+        body: "Markdown issue body describing the requested change, context, and acceptance criteria.",
+        title: "Concise GitHub issue title.",
+        word: "Short Vibe64 session label/word derived from the issue title."
+      },
+      doneMeaning: "You have enough information to propose a GitHub issue title, body, and Vibe64 session label for user review.",
+      waitingForInputMeaning: "You need more information from the user before drafting the issue."
+    });
   }
 };
 
 const makePlanMachine = {
   promptActionId: "make_plan",
-  stepId: planMadeStepId,
+  stepId: planAndExecuteStepId,
 
   initialState() {
     return machineState(STEP_STATUS.READY);
@@ -866,6 +1327,13 @@ const makePlanMachine = {
     return handleStandardPromptInput(context, this);
   },
 
+  inputCompletionMessage(context = {}) {
+    const input = normalizeMachineInput(context.input);
+    return input.kind === STEP_INPUT_KIND.READY
+      ? "Plan submitted for review."
+      : "";
+  },
+
   async actionStarted(context = {}) {
     return markPromptActionStarted(context, this, "make_plan");
   },
@@ -887,6 +1355,13 @@ const seedPlanMadeMachine = {
     return markPromptActionStarted(context, this, "make_seed_plan");
   },
 
+  inputCompletionMessage(context = {}) {
+    const input = normalizeMachineInput(context.input);
+    return input.kind === STEP_INPUT_KIND.READY
+      ? "Seed plan submitted for review."
+      : "";
+  },
+
   promptInstruction() {
     return currentStepHelperInstruction({
       doneMeaning: "The seed implementation plan has been written in the Codex response and is ready for execution.",
@@ -897,7 +1372,7 @@ const seedPlanMadeMachine = {
 
 const executePlanMachine = {
   promptActionId: "execute_plan",
-  stepId: planExecutedStepId,
+  stepId: planAndExecuteStepId,
 
   initialState() {
     return machineState(STEP_STATUS.READY);
@@ -922,6 +1397,13 @@ const executePlanMachine = {
     return handleStandardPromptInput(context, this);
   },
 
+  inputCompletionMessage(context = {}) {
+    const input = normalizeMachineInput(context.input);
+    return input.kind === STEP_INPUT_KIND.READY
+      ? "Implementation submitted for review."
+      : "";
+  },
+
   async actionStarted(context = {}) {
     return markPromptActionStarted(context, this, "execute_plan");
   },
@@ -934,6 +1416,195 @@ const executePlanMachine = {
   }
 };
 
+const planAndExecutePhase = Object.freeze({
+  EXECUTING: "executing",
+  PLANNING: "planning",
+  PLAN_READY: "plan_ready"
+});
+
+function planAndExecuteReadyState(details = {}) {
+  return machineState(STEP_STATUS.READY, {
+    phase: planAndExecutePhase.PLANNING,
+    ...details
+  });
+}
+
+function planAndExecutePlanReadyState(details = {}) {
+  return machineState(STEP_STATUS.READY, {
+    phase: planAndExecutePhase.PLAN_READY,
+    ...details
+  });
+}
+
+async function markPlanAndExecuteActionStarted(context = {}, machine = {}, {
+  actionId = "",
+  phase = ""
+} = {}) {
+  if (context.actionId !== actionId) {
+    return;
+  }
+  const state = await readState(context, machine);
+  switch (state.status) {
+    case STEP_STATUS.READY:
+    case STEP_STATUS.FAILED:
+    case STEP_STATUS.WAITING_FOR_INPUT:
+      await writeState(context, machine, machineState(STEP_STATUS.AWAITING_AGENT_RESULT, {
+        phase,
+        response: state.response,
+        source: state.source
+      }));
+      return;
+    case STEP_STATUS.AWAITING_AGENT_RESULT:
+    case STEP_STATUS.DONE:
+    default:
+      return;
+  }
+}
+
+const planAndExecuteMachine = {
+  promptActionId: "make_plan",
+  stepId: planAndExecuteStepId,
+
+  initialState(context = {}) {
+    if (metadataExists(context.session, IMPLEMENTATION_DONE_METADATA)) {
+      return machineState(STEP_STATUS.DONE, {
+        phase: planAndExecutePhase.EXECUTING
+      });
+    }
+    if (metadataExists(context.session, PLAN_READY_METADATA)) {
+      return planAndExecutePlanReadyState();
+    }
+    return planAndExecuteReadyState();
+  },
+
+  async view(context = {}) {
+    let state = await readState(context, this);
+    if (metadataExists(context.session, IMPLEMENTATION_DONE_METADATA)) {
+      state = machineState(STEP_STATUS.DONE, {
+        phase: planAndExecutePhase.EXECUTING
+      });
+    } else if (
+      metadataExists(context.session, PLAN_READY_METADATA) &&
+      ![STEP_STATUS.AWAITING_AGENT_RESULT, STEP_STATUS.WAITING_FOR_INPUT].includes(state.status)
+    ) {
+      state = planAndExecutePlanReadyState({
+        from: state.status
+      });
+    }
+
+    switch (state.status) {
+      case STEP_STATUS.DONE:
+        return promptStepDoneView(context, this, state);
+      case STEP_STATUS.WAITING_FOR_INPUT:
+        return promptStepWaitingForInputView(context, this, state, {
+          actionId: state.phase === planAndExecutePhase.EXECUTING ? "execute_plan" : "make_plan",
+          prompt: state.message || "Codex needs more information before this step can continue.",
+          skipInput: LET_CODEX_DECIDE_INPUT
+        });
+      case STEP_STATUS.READY:
+      case STEP_STATUS.AWAITING_AGENT_RESULT:
+      case STEP_STATUS.FAILED:
+      default:
+        return promptStepWaitingView(
+          context,
+          this,
+          state,
+          state.phase === planAndExecutePhase.PLAN_READY
+            ? "Ask Codex to execute the plan before continuing."
+            : "Ask Codex to make the plan before continuing."
+        );
+    }
+  },
+
+  async submitInput(context = {}) {
+    const state = await readState(context, this);
+    const input = normalizeMachineInput(context.input);
+    if (state.status === STEP_STATUS.AWAITING_AGENT_RESULT) {
+      assertAgentResultSource(context.session, input);
+    }
+
+    switch (state.status) {
+      case STEP_STATUS.READY:
+      case STEP_STATUS.AWAITING_AGENT_RESULT:
+      case STEP_STATUS.WAITING_FOR_INPUT:
+      case STEP_STATUS.FAILED:
+        if (input.kind === STEP_INPUT_KIND.WAITING_FOR_INPUT) {
+          await writeState(context, this, machineState(STEP_STATUS.WAITING_FOR_INPUT, {
+            from: STEP_STATUS.AWAITING_AGENT_RESULT,
+            message: input.message,
+            phase: state.phase || planAndExecutePhase.PLANNING,
+            source: input.source
+          }));
+          return;
+        }
+        if (input.kind === STEP_INPUT_KIND.USER_RESPONSE) {
+          await writeState(context, this, machineState(STEP_STATUS.READY, {
+            message: input.message,
+            phase: state.phase || planAndExecutePhase.PLANNING,
+            response: inputResponseText(input),
+            source: input.source
+          }));
+          return;
+        }
+        if (input.kind === STEP_INPUT_KIND.READY || input.kind === STEP_INPUT_KIND.CONSIDER_RESOLVED) {
+          if (state.phase === planAndExecutePhase.EXECUTING) {
+            await context.runtime.store.writeMetadataValue(context.session.sessionId, IMPLEMENTATION_DONE_METADATA, "yes");
+            await writeState(context, this, machineState(STEP_STATUS.DONE, {
+              message: input.message,
+              phase: planAndExecutePhase.EXECUTING,
+              source: input.source
+            }));
+            return;
+          }
+          await context.runtime.store.writeMetadataValue(context.session.sessionId, PLAN_READY_METADATA, "yes");
+          await writeState(context, this, planAndExecutePlanReadyState({
+            message: input.message,
+            source: input.source
+          }));
+          return;
+        }
+        throw unsupportedInputKind(input.kind, this.stepId);
+
+      case STEP_STATUS.DONE:
+      default:
+        throw vibe64Error("This step is already complete.", "vibe64_step_input_not_available");
+    }
+  },
+
+  inputCompletionMessage(context = {}) {
+    const input = normalizeMachineInput(context.input);
+    if (input.kind !== STEP_INPUT_KIND.READY) {
+      return "";
+    }
+    return context.session.stepMachine?.phase === planAndExecutePhase.EXECUTING
+      ? "Implementation submitted for review."
+      : "Plan submitted for review.";
+  },
+
+  async actionStarted(context = {}) {
+    await markPlanAndExecuteActionStarted(context, this, {
+      actionId: "make_plan",
+      phase: planAndExecutePhase.PLANNING
+    });
+    await markPlanAndExecuteActionStarted(context, this, {
+      actionId: "execute_plan",
+      phase: planAndExecutePhase.EXECUTING
+    });
+  },
+
+  promptInstruction({ action = {} } = {}) {
+    return normalizeText(action.id) === "execute_plan"
+      ? currentStepHelperInstruction({
+          doneMeaning: "The implementation work is complete enough to continue to review.",
+          waitingForInputMeaning: "You cannot continue implementation without a user decision or missing project detail."
+        })
+      : currentStepHelperInstruction({
+          doneMeaning: "The implementation plan has been written in the Codex response and is ready for execution.",
+          waitingForInputMeaning: "You cannot make a useful plan without a user decision or clarification."
+        });
+  }
+};
+
 const seedPlanExecutedMachine = {
   ...executePlanMachine,
   promptActionId: "execute_seed_plan",
@@ -943,6 +1614,13 @@ const seedPlanExecutedMachine = {
     return markPromptActionStarted(context, this, "execute_seed_plan");
   },
 
+  inputCompletionMessage(context = {}) {
+    const input = normalizeMachineInput(context.input);
+    return input.kind === STEP_INPUT_KIND.READY
+      ? "Seed implementation submitted for review."
+      : "";
+  },
+
   promptInstruction() {
     return currentStepHelperInstruction({
       doneMeaning: "The seed implementation work is complete enough to continue.",
@@ -960,6 +1638,13 @@ const deepUiCheckMachine = {
     return markPromptActionStarted(context, this, "run_deep_ui_check");
   },
 
+  inputCompletionMessage(context = {}) {
+    const input = normalizeMachineInput(context.input);
+    return input.kind === STEP_INPUT_KIND.READY
+      ? "The user interface check is done."
+      : "";
+  },
+
   promptInstruction() {
     return currentStepHelperInstruction({
       doneMeaning: "The deep UI check has been completed or intentionally found no required fix.",
@@ -968,87 +1653,357 @@ const deepUiCheckMachine = {
   }
 };
 
-const reviewRunMachine = {
-  ...executePlanMachine,
+const reviewAndValidatePhase = Object.freeze({
+  REVIEW: "review",
+  VALIDATION: "validation"
+});
+
+const reviewAndValidateCommandActionIds = Object.freeze(["update_code_index", "run_automated_checks"]);
+
+function reviewAndValidateComplete(session = {}) {
+  return metadataExists(session, REVIEW_DESLOP_COMPLETED_METADATA) &&
+    metadataExists(session, "code_index_updated") &&
+    metadataExists(session, "automated_checks_passed");
+}
+
+const reviewAndValidateMachine = {
   promptActionId: "run_deslop",
-  stepId: reviewRunStepId,
+  stepId: reviewAndValidateStepId,
 
-  async actionStarted(context = {}) {
-    return markPromptActionStarted(context, this, "run_deslop");
+  initialState(context = {}) {
+    if (reviewAndValidateComplete(context.session)) {
+      return machineState(STEP_STATUS.DONE);
+    }
+    return machineState(STEP_STATUS.READY, {
+      phase: metadataExists(context.session, REVIEW_DESLOP_COMPLETED_METADATA)
+        ? reviewAndValidatePhase.VALIDATION
+        : reviewAndValidatePhase.REVIEW
+    });
   },
 
-  promptInstruction() {
-    return currentStepHelperInstruction({
-      doneMeaning: "The review/deslop loop has completed and only acceptable low-risk findings remain.",
-      waitingForInputMeaning: "You cannot complete review/deslop without a user decision."
-    });
-  }
-};
+  async view(context = {}) {
+    let state = await readState(context, this);
+    if (reviewAndValidateComplete(context.session)) {
+      state = machineState(STEP_STATUS.DONE);
+    } else if (
+      metadataExists(context.session, REVIEW_DESLOP_COMPLETED_METADATA) &&
+      ![STEP_STATUS.AWAITING_AGENT_RESULT, STEP_STATUS.ATTEMPTING_EXECUTION, STEP_STATUS.WAITING_FOR_INPUT].includes(state.status)
+    ) {
+      state = machineState(STEP_STATUS.READY, {
+        phase: reviewAndValidatePhase.VALIDATION
+      });
+    }
 
-const projectKnowledgeUpdatedMachine = {
-  ...executePlanMachine,
-  promptActionId: "update_project_knowledge",
-  stepId: projectKnowledgeUpdatedStepId,
+    switch (state.status) {
+      case STEP_STATUS.DONE:
+        return promptStepDoneView(context, this, state);
+      case STEP_STATUS.WAITING_FOR_INPUT:
+        return state.phase === reviewAndValidatePhase.VALIDATION
+          ? {
+              interaction: commandFailureInteraction({
+                prompt: state.message || "The validation command failed. Explain what should happen, then retry validation.",
+                title: state.title || "Validation needs attention"
+              }),
+              next: nextForSession(context.session, {
+                disabledReason: "Run review/deslop, update the code index, and run automated checks successfully before continuing."
+              }),
+              stepMachine: publicState(this, state)
+            }
+          : promptStepWaitingForInputView(context, this, state, {
+              actionId: "run_deslop",
+              prompt: state.message || "Codex needs more information before review/deslop can continue.",
+              skipInput: LET_CODEX_DECIDE_INPUT,
+              title: "Review needs input"
+            });
+      case STEP_STATUS.READY:
+      case STEP_STATUS.AWAITING_AGENT_RESULT:
+      case STEP_STATUS.ATTEMPTING_EXECUTION:
+      case STEP_STATUS.FAILED:
+      default:
+        return promptStepWaitingView(
+          context,
+          this,
+          state,
+          "Run review/deslop, update the code index, and run automated checks successfully before continuing."
+        );
+    }
+  },
+
+  async submitInput(context = {}) {
+    const state = await readState(context, this);
+    const input = normalizeMachineInput(context.input);
+    if (state.status === STEP_STATUS.AWAITING_AGENT_RESULT) {
+      assertAgentResultSource(context.session, input);
+    }
+
+    switch (state.status) {
+      case STEP_STATUS.READY:
+      case STEP_STATUS.AWAITING_AGENT_RESULT:
+      case STEP_STATUS.WAITING_FOR_INPUT:
+      case STEP_STATUS.FAILED:
+        if (input.kind === STEP_INPUT_KIND.WAITING_FOR_INPUT) {
+          await writeState(context, this, machineState(STEP_STATUS.WAITING_FOR_INPUT, {
+            from: STEP_STATUS.AWAITING_AGENT_RESULT,
+            message: input.message,
+            phase: state.phase || reviewAndValidatePhase.REVIEW,
+            source: input.source
+          }));
+          return;
+        }
+        if (input.kind === STEP_INPUT_KIND.USER_RESPONSE || input.kind === STEP_INPUT_KIND.CONSIDER_RESOLVED) {
+          await writeState(context, this, machineState(STEP_STATUS.READY, {
+            phase: state.phase || reviewAndValidatePhase.REVIEW,
+            response: inputResponseText(input),
+            source: input.source
+          }));
+          return;
+        }
+        if (input.kind === STEP_INPUT_KIND.READY) {
+          await context.runtime.store.writeMetadataValue(
+            context.session.sessionId,
+            REVIEW_DESLOP_COMPLETED_METADATA,
+            "yes"
+          );
+          await writeState(context, this, machineState(STEP_STATUS.READY, {
+            message: input.message,
+            phase: reviewAndValidatePhase.VALIDATION,
+            source: input.source
+          }));
+          return;
+        }
+        throw unsupportedInputKind(input.kind, this.stepId);
+
+      case STEP_STATUS.DONE:
+      case STEP_STATUS.ATTEMPTING_EXECUTION:
+      default:
+        throw vibe64Error("This step cannot accept input right now.", "vibe64_step_input_not_available");
+    }
+  },
+
+  inputCompletionMessage(context = {}) {
+    const input = normalizeMachineInput(context.input);
+    return input.kind === STEP_INPUT_KIND.READY
+      ? "Review/deslop completed."
+      : "";
+  },
 
   async actionStarted(context = {}) {
-    return markPromptActionStarted(context, this, "update_project_knowledge");
+    if (context.actionId === "run_deslop") {
+      return markPromptActionStarted(context, this, "run_deslop");
+    }
+    if (!reviewAndValidateCommandActionIds.includes(context.actionId)) {
+      return;
+    }
+    const state = await readState(context, this);
+    switch (state.status) {
+      case STEP_STATUS.READY:
+      case STEP_STATUS.FAILED:
+      case STEP_STATUS.WAITING_FOR_INPUT:
+        await writeState(context, this, machineState(STEP_STATUS.ATTEMPTING_EXECUTION, {
+          actionId: context.actionId,
+          phase: reviewAndValidatePhase.VALIDATION
+        }));
+        return;
+
+      case STEP_STATUS.ATTEMPTING_EXECUTION:
+      case STEP_STATUS.DONE:
+      default:
+        return;
+    }
+  },
+
+  async actionFinished(context = {}) {
+    if (!reviewAndValidateCommandActionIds.includes(context.actionId)) {
+      return;
+    }
+    const state = await readState(context, this);
+    switch (state.status) {
+      case STEP_STATUS.ATTEMPTING_EXECUTION:
+      case STEP_STATUS.READY:
+      case STEP_STATUS.WAITING_FOR_INPUT:
+      case STEP_STATUS.FAILED:
+        if (reviewAndValidateComplete(await context.runtime.getSession(context.session.sessionId))) {
+          await writeState(context, this, machineState(STEP_STATUS.DONE));
+          return;
+        }
+        if (actionCompleted(context.actionResult)) {
+          await writeState(context, this, machineState(STEP_STATUS.READY, {
+            phase: reviewAndValidatePhase.VALIDATION
+          }));
+          return;
+        }
+        await writeState(context, this, machineState(STEP_STATUS.WAITING_FOR_INPUT, {
+          from: STEP_STATUS.ATTEMPTING_EXECUTION,
+          message: normalizeText(context.actionResult?.message),
+          output: normalizeText(context.actionResult?.output),
+          phase: reviewAndValidatePhase.VALIDATION,
+          title: "Validation needs attention"
+        }));
+        return;
+
+      case STEP_STATUS.DONE:
+      default:
+        return;
+    }
   },
 
   promptInstruction() {
     return currentStepHelperInstruction({
-      doneMeaning: "Project knowledge has been updated or there is no adapter-supported project knowledge to update.",
-      waitingForInputMeaning: "You cannot update project knowledge without a user decision."
+      doneMeaning: "The review/deslop loop has completed and only acceptable low-risk findings remain.",
+      waitingForInputMeaning: "You cannot complete review/deslop without a user decision."
     });
   }
 };
 
-const reportCreatedMachine = {
+const reportAndKnowledgePhase = Object.freeze({
+  KNOWLEDGE: "knowledge",
+  REPORT: "report"
+});
+
+function reportAndKnowledgeComplete(session = {}) {
+  return artifactIsReady(session, REPORT_ARTIFACT) &&
+    metadataExists(session, PROJECT_KNOWLEDGE_UPDATED_METADATA);
+}
+
+const reportAndKnowledgeUpdatedMachine = {
   promptActionId: "write_report",
-  stepId: reportCreatedStepId,
+  stepId: reportAndKnowledgeUpdatedStepId,
 
   initialState(context = {}) {
-    return artifactIsReady(context.session, REPORT_ARTIFACT)
-      ? machineState(STEP_STATUS.DONE)
-      : machineState(STEP_STATUS.READY);
+    if (reportAndKnowledgeComplete(context.session)) {
+      return machineState(STEP_STATUS.DONE);
+    }
+    return machineState(STEP_STATUS.READY, {
+      phase: artifactIsReady(context.session, REPORT_ARTIFACT)
+        ? reportAndKnowledgePhase.KNOWLEDGE
+        : reportAndKnowledgePhase.REPORT
+    });
   },
 
   async view(context = {}) {
     let state = await readState(context, this);
-    if (artifactIsReady(context.session, REPORT_ARTIFACT)) {
+    if (reportAndKnowledgeComplete(context.session)) {
       state = machineState(STEP_STATUS.DONE);
+    } else if (
+      artifactIsReady(context.session, REPORT_ARTIFACT) &&
+      ![STEP_STATUS.AWAITING_AGENT_RESULT, STEP_STATUS.WAITING_FOR_INPUT].includes(state.status)
+    ) {
+      state = machineState(STEP_STATUS.READY, {
+        phase: reportAndKnowledgePhase.KNOWLEDGE
+      });
     }
 
     switch (state.status) {
       case STEP_STATUS.DONE:
         return promptStepDoneView(context, this, state);
       case STEP_STATUS.WAITING_FOR_INPUT:
-        return promptStepWaitingForInputView(context, this, state);
+        return promptStepWaitingForInputView(context, this, state, {
+          actionId: state.phase === reportAndKnowledgePhase.KNOWLEDGE ? "update_project_knowledge" : "write_report",
+          prompt: state.message || "Codex needs more information before this step can continue.",
+          skipInput: LET_CODEX_DECIDE_INPUT
+        });
       case STEP_STATUS.READY:
       case STEP_STATUS.AWAITING_AGENT_RESULT:
       case STEP_STATUS.FAILED:
       default:
-        return promptStepWaitingView(context, this, state, "Write the session report before updating project knowledge.");
+        return promptStepWaitingView(context, this, state, "Write the report and update project knowledge before continuing.");
     }
   },
 
   async submitInput(context = {}) {
-    return handleStandardPromptInput(context, this, {
-      responseArtifact: REPORT_ARTIFACT
-    });
+    const state = await readState(context, this);
+    const input = normalizeMachineInput(context.input);
+    if (state.status === STEP_STATUS.AWAITING_AGENT_RESULT) {
+      assertAgentResultSource(context.session, input);
+    }
+
+    switch (state.status) {
+      case STEP_STATUS.READY:
+      case STEP_STATUS.AWAITING_AGENT_RESULT:
+      case STEP_STATUS.WAITING_FOR_INPUT:
+      case STEP_STATUS.FAILED:
+        if (input.kind === STEP_INPUT_KIND.WAITING_FOR_INPUT) {
+          await writeState(context, this, machineState(STEP_STATUS.WAITING_FOR_INPUT, {
+            from: STEP_STATUS.AWAITING_AGENT_RESULT,
+            message: input.message,
+            phase: state.phase || reportAndKnowledgePhase.REPORT,
+            source: input.source
+          }));
+          return;
+        }
+        if (input.kind !== STEP_INPUT_KIND.READY && input.kind !== STEP_INPUT_KIND.CONSIDER_RESOLVED) {
+          throw unsupportedInputKind(input.kind, this.stepId);
+        }
+        if (state.phase === reportAndKnowledgePhase.KNOWLEDGE) {
+          await context.runtime.store.writeMetadataValue(
+            context.session.sessionId,
+            PROJECT_KNOWLEDGE_UPDATED_METADATA,
+            "yes"
+          );
+          await writeState(context, this, machineState(STEP_STATUS.DONE, {
+            message: input.message,
+            phase: reportAndKnowledgePhase.KNOWLEDGE,
+            source: input.source
+          }));
+          return;
+        }
+        await writePromptResponseArtifact(context, REPORT_ARTIFACT, input.fields.response || input.text);
+        await writeState(context, this, machineState(STEP_STATUS.READY, {
+          message: input.message,
+          phase: reportAndKnowledgePhase.KNOWLEDGE,
+          source: input.source
+        }));
+        return;
+
+      case STEP_STATUS.DONE:
+      default:
+        throw vibe64Error("This step is already complete.", "vibe64_step_input_not_available");
+    }
+  },
+
+  inputCompletionMessage(context = {}) {
+    const input = normalizeMachineInput(context.input);
+    if (input.kind !== STEP_INPUT_KIND.READY) {
+      return "";
+    }
+    return context.session.stepMachine?.phase === reportAndKnowledgePhase.KNOWLEDGE
+      ? "Project knowledge update completed."
+      : "Report submitted for review.";
   },
 
   async actionStarted(context = {}) {
-    return markPromptActionStarted(context, this, "write_report");
+    const phaseByActionId = {
+      update_project_knowledge: reportAndKnowledgePhase.KNOWLEDGE,
+      write_report: reportAndKnowledgePhase.REPORT
+    };
+    const phase = phaseByActionId[context.actionId];
+    if (!phase) {
+      return;
+    }
+    const state = await readState(context, this);
+    if (![STEP_STATUS.READY, STEP_STATUS.FAILED, STEP_STATUS.WAITING_FOR_INPUT].includes(state.status)) {
+      return;
+    }
+    await writeState(context, this, machineState(STEP_STATUS.AWAITING_AGENT_RESULT, {
+      phase,
+      response: state.response,
+      source: state.source
+    }));
   },
 
-  promptInstruction() {
-    return currentStepHelperInstruction({
-      doneFields: {
-        response: "Markdown session report"
-      },
-      doneMeaning: "The report text is complete and should be saved by Studio as the session report.",
-      waitingForInputMeaning: "You cannot write the report without a user decision or missing context."
-    });
+  promptInstruction({ action = {} } = {}) {
+    return normalizeText(action.id) === "update_project_knowledge"
+      ? currentStepHelperInstruction({
+          doneMeaning: "Project knowledge has been updated or there is no adapter-supported project knowledge to update.",
+          waitingForInputMeaning: "You cannot update project knowledge without a user decision."
+        })
+      : currentStepHelperInstruction({
+          doneFields: {
+            response: "Markdown session report"
+          },
+          doneMeaning: "The report text is complete and should be saved by Studio as the session report.",
+          waitingForInputMeaning: "You cannot write the report without a user decision or missing context."
+        });
   }
 };
 
@@ -1056,6 +2011,7 @@ const coreCodingSteps = Object.freeze(Object.values(Object.freeze({
   [SEED_APPLICATION_STEP_ID]: {
     config: {
       draftReady: issueFilesAreReady,
+      completionMessage: "Seed issue draft submitted for review.",
       initialDetails: {
         doing: "discussion"
       },
@@ -1080,51 +2036,9 @@ const coreCodingSteps = Object.freeze(Object.values(Object.freeze({
     id: SEED_APPLICATION_STEP_ID
   },
   [ISSUE_FILE_STEP_ID]: {
-    config: {
-      command: {
-        actionId: "use_existing_issue",
-        doneMetadata: "issue_url",
-        failureState: (context = {}) => machineState(STEP_STATUS.FAILED, {
-          message: normalizeText(context.actionResult?.message)
-        }),
-        finishStatuses: [
-          STEP_STATUS.WAITING_FOR_INPUT,
-          STEP_STATUS.CONFIRM_FILES,
-          STEP_STATUS.FAILED
-        ],
-        markAttemptingOnStart: false
-      },
-      done: (session = {}) => metadataExists(session, "issue_url"),
-      draftReady: issueFilesAreReady,
-      initialDetails: {
-        doing: "discussion"
-      },
-      interaction: issueInputInteraction,
-      nextWhenDrafting: {
-        disabledReason: "Define and save the issue before continuing."
-      },
-      nextWhenWorking: {
-        disabledReason: "Define and save the issue before continuing."
-      },
-      onConfirmedActions: (context = {}) => disableAction(context.session, "use_existing_issue", "Issue details are already saved."),
-      onDoneActions: (context = {}) => disableAction(context.session, "use_existing_issue", "An existing issue is already selected."),
-      readValues: readIssueFieldValues,
-      saveValues: writeIssueFieldValues,
-      unsupportedDoneMessage: "The issue is already complete.",
-      waitingForInputState: (input = {}) => ({
-        doing: "discussion",
-        message: input.message
-      }),
-      waitingInteraction: () => issueInputInteraction(STEP_STATUS.WAITING_FOR_INPUT, {})
-    },
     definition: coreCodingStepDefinitionsById[ISSUE_FILE_STEP_ID],
-    factoryId: "editable_artifact_review",
-    id: ISSUE_FILE_STEP_ID
-  },
-  [issueSubmittedStepId]: {
-    definition: coreCodingStepDefinitionsById[issueSubmittedStepId],
-    id: issueSubmittedStepId,
-    machine: issueSubmittedMachine
+    id: ISSUE_FILE_STEP_ID,
+    machine: issueFileMachine
   },
   [seedPlanMadeStepId]: {
     definition: coreCodingStepDefinitionsById[seedPlanMadeStepId],
@@ -1136,18 +2050,14 @@ const coreCodingSteps = Object.freeze(Object.values(Object.freeze({
     id: seedPlanExecutedStepId,
     machine: seedPlanExecutedMachine
   },
-  [planMadeStepId]: {
-    definition: coreCodingStepDefinitionsById[planMadeStepId],
-    id: planMadeStepId,
-    machine: makePlanMachine
-  },
-  [planExecutedStepId]: {
-    definition: coreCodingStepDefinitionsById[planExecutedStepId],
-    id: planExecutedStepId,
-    machine: executePlanMachine
+  [planAndExecuteStepId]: {
+    definition: coreCodingStepDefinitionsById[planAndExecuteStepId],
+    id: planAndExecuteStepId,
+    machine: planAndExecuteMachine
   },
   [implementationReviewedStepId]: {
     config: {
+      completionMessage: "Initial human review turn completed.",
       completionPolicy: {
         decidedBy: "ai",
         enoughWhen: "the requested focused tweak has either been made and focused checks run when practical, or you can clearly report that no code change is needed.",
@@ -1160,33 +2070,19 @@ const coreCodingSteps = Object.freeze(Object.values(Object.freeze({
     factoryId: "chat_with_ai",
     id: implementationReviewedStepId
   },
-  [agentConversationStepId]: {
-    config: {
-      completionPolicy: {
-        decidedBy: "user"
-      },
-      nextWhenIdle: (context = {}) => ({
-        disabledReason: "Ask Codex for changes before continuing.",
-        enabled: artifactIsReady(context.session, HUMAN_INPUT_RESPONSE_ARTIFACT)
-      }),
-      promptActionId: "agent_conversation"
-    },
-    definition: coreCodingStepDefinitionsById[agentConversationStepId],
-    factoryId: "chat_with_ai",
-    id: agentConversationStepId
-  },
   [deepUiCheckRunStepId]: {
     definition: coreCodingStepDefinitionsById[deepUiCheckRunStepId],
     id: deepUiCheckRunStepId,
     machine: deepUiCheckMachine
   },
-  [reviewRunStepId]: {
-    definition: coreCodingStepDefinitionsById[reviewRunStepId],
-    id: reviewRunStepId,
-    machine: reviewRunMachine
+  [reviewAndValidateStepId]: {
+    definition: coreCodingStepDefinitionsById[reviewAndValidateStepId],
+    id: reviewAndValidateStepId,
+    machine: reviewAndValidateMachine
   },
   [changesAcceptedStepId]: {
     config: {
+      completionMessage: "Final human review turn completed.",
       completionPolicy: {
         decidedBy: "ai",
         enoughWhen: "the requested final tweak has either been made or you can clearly report the blocker; Vibe64 can then rerun review and validation.",
@@ -1199,15 +2095,10 @@ const coreCodingSteps = Object.freeze(Object.values(Object.freeze({
     factoryId: "chat_with_ai",
     id: changesAcceptedStepId
   },
-  [reportCreatedStepId]: {
-    definition: coreCodingStepDefinitionsById[reportCreatedStepId],
-    id: reportCreatedStepId,
-    machine: reportCreatedMachine
-  },
-  [projectKnowledgeUpdatedStepId]: {
-    definition: coreCodingStepDefinitionsById[projectKnowledgeUpdatedStepId],
-    id: projectKnowledgeUpdatedStepId,
-    machine: projectKnowledgeUpdatedMachine
+  [reportAndKnowledgeUpdatedStepId]: {
+    definition: coreCodingStepDefinitionsById[reportAndKnowledgeUpdatedStepId],
+    id: reportAndKnowledgeUpdatedStepId,
+    machine: reportAndKnowledgeUpdatedMachine
   }
 })));
 
@@ -1218,22 +2109,19 @@ const coreCodingWorkflowModule = Object.freeze({
 });
 
 const _testing = deepFreeze({
+  groupIds: CORE_CODING_WORKFLOW_GROUP_IDS,
   moduleId,
   ownedStepIds: [
     SEED_APPLICATION_STEP_ID,
     ISSUE_FILE_STEP_ID,
-    issueSubmittedStepId,
     seedPlanMadeStepId,
     seedPlanExecutedStepId,
-    planMadeStepId,
-    planExecutedStepId,
+    planAndExecuteStepId,
     implementationReviewedStepId,
-    agentConversationStepId,
     deepUiCheckRunStepId,
-    reviewRunStepId,
+    reviewAndValidateStepId,
     changesAcceptedStepId,
-    reportCreatedStepId,
-    projectKnowledgeUpdatedStepId
+    reportAndKnowledgeUpdatedStepId
   ],
   workflowDefinitionIds: VIBE64_WORKFLOW_DEFINITION_IDS
 });
@@ -1244,5 +2132,7 @@ export {
   ISSUE_FILE_STEP_ID,
   SEED_APPLICATION_STEP_ID,
   _testing,
-  coreCodingWorkflowModule
+  coreCodingWorkflowModule,
+  finishOffWorkflowGroup,
+  qaWorkflowGroup
 };