vibe64 0.1.21 → 0.1.22

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

@@ -5,9 +5,6 @@ import {
 import {
   buildAgentConversationStepDefinition
 } from "../workflowDefinitionBuilders.js";
-import {
-  coreLifecycleWorkflowIntentHandlers
-} from "./coreLifecycle.js";
 import { when } from "../workflowConditions.js";
 import {
   STEP_STATUS,
@@ -25,7 +22,6 @@ import {
 const moduleId = "core.maintenance";
 const localSessionFinishedStepId = "local_session_finished";
 const workflowDefinitionIds = deepFreeze({
-  NON_CODE_MAINTENANCE: "non_code_maintenance",
   NON_COMMIT_MAINTENANCE: "non_commit_maintenance"
 });
 
@@ -87,33 +83,15 @@ const coreMaintenanceStepDefinitionsById = deepFreeze({
 });
 
 const coreMaintenanceWorkflowDefinitions = [
-  {
-    description: "Update documentation or other non-code project files, validate, commit, create a PR, and optionally merge.",
-    id: workflowDefinitionIds.NON_CODE_MAINTENANCE,
-    intentHandlers: coreLifecycleWorkflowIntentHandlers,
-    label: "Documentation/non code maintenance",
-    sessionWord: "documentation",
-    steps: [
-      "session_created",
-      "work_source_selected",
-      "worktree_created",
-      "dependencies_installed",
-      "maintenance_conversation",
-      "project_validated",
-      "changes_committed",
-      "create_pull_request",
-      "pr_merged",
-      "main_checkout_synced",
-      "session_finished"
-    ],
-    userSelectable: true
-  },
   {
     description: "Run a local maintenance task without commit, pull request, or merge steps.",
     id: workflowDefinitionIds.NON_COMMIT_MAINTENANCE,
     label: "Non-commit maintenance",
     initialMetadata: {
-      work_source: "new_branch"
+      github_issue_mode: "skip",
+      issue_source: "none",
+      work_anchor_type: "description",
+      work_source: "description"
     },
     sessionWord: "maintenance",
     steps: [
@@ -168,6 +146,7 @@ const localSessionFinishedMachine = {
 const coreMaintenanceSteps = Object.freeze([
   {
     config: {
+      completionMessage: "Maintenance conversation turn completed.",
       completionPolicy: {
         decidedBy: "user"
       },

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

@@ -15,6 +15,9 @@ import {
   vibe64SessionDebugLog,
   vibe64SessionDebugSummary
 } from "./sessionDebugLog.js";
+import {
+  sessionHasWorktree
+} from "./sessionWorktreeState.js";
 import { STEP_STATUS } from "./workflowStepMachines.js";
 
 // Vibe64 ownership contract:
@@ -33,6 +36,7 @@ const INTENT_IDS = Object.freeze({
 });
 
 const COMMAND_RECOVERY_DELAY_MS = 5000;
+const CODEX_BOOTSTRAP_TASK_ID = "codex_bootstrap";
 const COMMAND_LIFECYCLE_RUNNING_PHASES = Object.freeze(new Set([
   "starting",
   "started"
@@ -152,18 +156,26 @@ function inputPresentation(input = {}, {
 
 function intent(id, {
   actionId = "",
+  auditMessage = "",
   disabledReason = "",
   enabled = true,
   control = null,
   input = null,
   inputFields = [],
   label = "",
-  style = "secondary"
+  operation = "",
+  saveCurrentStepInputBeforeRun = false,
+  style = "secondary",
+  submitFields = null
 } = {}) {
   const controlPresentation = isPlainObject(control) ? normalizeControlPresentation(control) : null;
   const intentInputPresentation = isPlainObject(input) ? input : null;
+  const intentSubmitFields = isPlainObject(submitFields) ? submitFields : null;
+  const normalizedAuditMessage = normalizeText(auditMessage);
+  const normalizedOperation = normalizeText(operation);
   return {
     actionId: normalizeText(actionId),
+    ...(normalizedAuditMessage ? { auditMessage: normalizedAuditMessage } : {}),
     ...(controlPresentation ? { control: controlPresentation } : {}),
     disabledReason: enabled ? "" : normalizeText(disabledReason || "This action is not available right now."),
     enabled: enabled === true,
@@ -171,6 +183,9 @@ function intent(id, {
     ...(intentInputPresentation ? { input: intentInputPresentation } : {}),
     inputFields: Array.isArray(inputFields) ? inputFields : [],
     label: normalizeText(label || id),
+    ...(normalizedOperation ? { operation: normalizedOperation } : {}),
+    ...(saveCurrentStepInputBeforeRun === true ? { saveCurrentStepInputBeforeRun: true } : {}),
+    ...(intentSubmitFields ? { submitFields: intentSubmitFields } : {}),
     style
   };
 }
@@ -219,25 +234,33 @@ function normalizeControlPresentation(control = {}) {
 }
 
 function intentForAction(id, action = {}, options = {}) {
+  const configuredInputFields = Array.isArray(options.inputFields) && options.inputFields.length > 0
+    ? options.inputFields
+    : null;
   return intent(id, {
     ...options,
     actionId: action?.id || options.actionId || "",
     disabledReason: action?.disabledReason || options.disabledReason || "",
     enabled: action?.enabled === true,
     input: options.input,
-    inputFields: options.inputFields || action?.inputFields || [],
+    inputFields: configuredInputFields || action?.inputFields || [],
     label: options.label || action?.label || id
   });
 }
 
 function continueIntent(session = {}, {
+  auditMessage = "",
   id = INTENT_IDS.CONTINUE_STEP,
-  label = ""
+  label = "",
+  saveCurrentStepInputBeforeRun = false
 } = {}) {
   return intent(normalizeText(id) || INTENT_IDS.CONTINUE_STEP, {
+    auditMessage,
     disabledReason: session.next?.disabledReason || "",
     enabled: nextIsReady(session),
     label: label || session.next?.label || "Continue",
+    operation: "continue",
+    saveCurrentStepInputBeforeRun,
     style: "primary"
   });
 }
@@ -329,17 +352,21 @@ function intentFromConfig(session = {}, config = {}) {
   }
   if (normalizeText(config.type) === "continue") {
     return continueIntent(session, {
+      auditMessage: config.auditMessage,
       id,
-      label: config.label
+      label: config.label,
+      saveCurrentStepInputBeforeRun: config.saveCurrentStepInputBeforeRun === true
     });
   }
   if (normalizeText(config.type) === "reject") {
     const enabled = Boolean(rejectTargetStepId(session));
     return intent(id, {
+      auditMessage: config.auditMessage,
       disabledReason: enabled ? "" : "This workflow does not define a rejection target for the current step.",
       enabled,
       inputFields: config.inputFields,
       label: config.label || "Reject",
+      operation: "reject",
       style: config.style || "secondary"
     });
   }
@@ -347,9 +374,11 @@ function intentFromConfig(session = {}, config = {}) {
     const stage = stageAction(session);
     const action = actionById(session, config.actionId || stage?.actionId || "");
     return intentForAction(id, action, {
+      auditMessage: config.auditMessage,
       disabledReason: config.disabledReason || "",
       inputFields: config.inputFields,
       label: config.label || "",
+      saveCurrentStepInputBeforeRun: config.saveCurrentStepInputBeforeRun === true,
       style: config.style || "secondary"
     });
   }
@@ -357,12 +386,17 @@ function intentFromConfig(session = {}, config = {}) {
   const enabled = configuredIntentEnabled(session, config);
   return intent(id, {
     actionId: config.actionId || "",
+    auditMessage: config.auditMessage,
     control: config.control,
     disabledReason: action?.disabledReason || configuredIntentDisabledReason(session, config, enabled),
     enabled: action ? action.enabled === true && enabled : enabled,
     input: config.input,
-    inputFields: config.inputFields || action?.inputFields || [],
+    inputFields: Array.isArray(config.inputFields) && config.inputFields.length > 0
+      ? config.inputFields
+      : action?.inputFields || [],
     label: config.label || action?.label || "",
+    saveCurrentStepInputBeforeRun: config.saveCurrentStepInputBeforeRun === true,
+    submitFields: config.submitFields,
     style: config.style || "secondary"
   });
 }
@@ -377,15 +411,27 @@ function presentationFromConfig(session = {}, config = {}) {
   };
 }
 
-function configuredStopIntentsExcept(session = {}, excludedIntentIds = []) {
+function fallbackContinueIntentExcept(session = {}, excluded = new Set()) {
+  if (session.next?.visible === false || !session.next?.stepId) {
+    return [];
+  }
+  const fallback = continueIntent(session);
+  return excluded.has(fallback.id) ? [] : [fallback];
+}
+
+function configuredStopIntentsExcept(session = {}, excludedIntentIds = [], {
+  useConfigured = true
+} = {}) {
   const excluded = new Set(excludedIntentIds.map(normalizeText).filter(Boolean));
+  if (!useConfigured) {
+    return fallbackContinueIntentExcept(session, excluded);
+  }
   const stopIntents = stopScreenPresentation(session).intents
     .filter((candidate) => !excluded.has(candidate.id));
   if (stopIntents.length > 0 || session.next?.visible === false || !session.next?.stepId) {
     return stopIntents;
   }
-  const fallback = continueIntent(session);
-  return excluded.has(fallback.id) ? [] : [fallback];
+  return fallbackContinueIntentExcept(session, excluded);
 }
 
 function stopScreenPresentation(session = {}) {
@@ -402,6 +448,11 @@ function stopScreenPresentation(session = {}) {
   };
 }
 
+function stopPresentationPersistsWhenComplete(session = {}) {
+  const configured = stepPresentationConfig(session).stop;
+  return isPlainObject(configured) && configured.persistWhenComplete === true;
+}
+
 function userDecisionPresentation(session = {}) {
   const configured = stepPresentationConfig(session).decision;
   if (isPlainObject(configured)) {
@@ -428,6 +479,30 @@ function userDecisionPresentation(session = {}) {
   };
 }
 
+function interactionIntents(session = {}, interaction = {}) {
+  return (Array.isArray(interaction.intents) ? interaction.intents : [])
+    .map((intentConfig) => intentFromConfig(session, intentConfig))
+    .filter(Boolean);
+}
+
+function conversationSkipIntent(interaction = {}, action = {}) {
+  const skipInput = isPlainObject(interaction.skipInput) ? interaction.skipInput : null;
+  const message = normalizeText(skipInput?.message);
+  if (!skipInput || !message) {
+    return null;
+  }
+  return intent(skipInput.id || "let_codex_decide", {
+    actionId: action?.id || "",
+    disabledReason: action?.disabledReason || "",
+    enabled: action?.enabled === true,
+    label: skipInput.label || "Let Codex decide",
+    style: skipInput.style || "secondary",
+    submitFields: {
+      conversationRequest: message
+    }
+  });
+}
+
 function interactionPresentation(session = {}) {
   const interaction = currentStepDefinition(session).interaction;
   if (!isPlainObject(interaction)) {
@@ -446,10 +521,13 @@ function interactionPresentation(session = {}) {
       label: interaction.submitLabel || action?.label || "Send to Codex",
       style: "primary"
     });
+    const waitingForInput = stepMachineStatus(session) === STEP_STATUS.WAITING_FOR_INPUT;
+    const skipIntent = waitingForInput ? conversationSkipIntent(interaction, action) : null;
     return {
       intents: [
         primaryIntent,
-        ...configuredStopIntentsExcept(session, [conversationIntentId])
+        ...(skipIntent ? [skipIntent] : []),
+        ...(waitingForInput ? [] : configuredStopIntentsExcept(session, [conversationIntentId]))
       ],
       screen: screen("conversation", {
         input: inputPresentation(interaction, {
@@ -463,7 +541,7 @@ function interactionPresentation(session = {}) {
     };
   }
   return {
-    intents: [],
+    intents: interactionIntents(session, interaction),
     screen: screen(stepMachineStatus(session) === STEP_STATUS.CONFIRM_FILES ? "confirm_files" : "input", {
       input: inputPresentation(interaction, {
         submitTarget: "current-step-input"
@@ -502,7 +580,7 @@ function waitingPresentation(session = {}) {
       icon: "progress",
       message: "Wait for Codex to finish the current step.",
       showProgress: true,
-      title: "Terminal is transmitting..."
+      title: "Codex is thinking..."
     })
   };
 }
@@ -512,6 +590,9 @@ function genericPresentation(session = {}) {
     return {
       intents: [continueIntent(session)],
       screen: screen("ready", {
+        message: stepMachineStatus(session) === STEP_STATUS.DONE
+          ? session.stepMachine?.message || `${currentStepLabel(session)} completed.`
+          : "",
         title: currentStepLabel(session)
       })
     };
@@ -533,9 +614,15 @@ function automationWaitReason(session = {}) {
     return "input";
   }
   if (currentAutopilot(session).stop === true) {
+    if (stepMachineStatus(session) === STEP_STATUS.DONE && nextIsReady(session) && !stopPresentationPersistsWhenComplete(session)) {
+      return "";
+    }
     return "user";
   }
   if (currentAutopilot(session).userDecision === true) {
+    if (stepMachineStatus(session) === STEP_STATUS.DONE && nextIsReady(session)) {
+      return "";
+    }
     return "decision";
   }
   return "";
@@ -698,12 +785,22 @@ function mergeOperation(session = {}, config = {}) {
   const metadata = session.metadata || {};
   const skippedMetadataName = requiredPresentationValue(config, "skippedMetadataName", "merge automation");
   const mergedMetadataName = requiredPresentationValue(config, "mergedMetadataName", "merge automation");
+  const syncActionId = normalizeText(config.syncActionId);
+  const syncedMetadataName = normalizeText(config.syncedMetadataName);
   if (normalizeText(metadata[skippedMetadataName])) {
     return nextIsReady(session)
       ? advanceOperation(session)
       : stopOperation(session.next?.disabledReason || "");
   }
   if (normalizeText(metadata[mergedMetadataName])) {
+    if (syncActionId && syncedMetadataName && !normalizeText(metadata[syncedMetadataName])) {
+      if (stepMachineIsWaitingForCodex(session) || stepMachineNeedsInput(session)) {
+        return waitOperation(automationWaitReason(session));
+      }
+      return actionOperation(session, {
+        actionId: syncActionId
+      });
+    }
     return nextIsReady(session)
       ? advanceOperation(session)
       : stopOperation(session.next?.disabledReason || "");
@@ -761,10 +858,6 @@ function nextAutomationOperation(session = {}) {
     return waitOperation(waitReason);
   }
 
-  if (stepMachineStatus(session) === STEP_STATUS.DONE && nextIsReady(session)) {
-    return advanceOperation(session);
-  }
-
   const stage = stageAction(session);
   if (stage) {
     return actionOperation(session, stage);
@@ -784,7 +877,7 @@ function promptPresentation(session = {}) {
     case STEP_STATUS.ATTEMPTING_EXECUTION:
       return {
         state: "waiting_for_agent",
-        statusText: "Waiting for Codex."
+        statusText: "Codex is thinking."
       };
     case STEP_STATUS.CONFIRM_FILES:
     case STEP_STATUS.WAITING_FOR_INPUT:
@@ -811,7 +904,14 @@ function promptPresentation(session = {}) {
   }
 }
 
-function backgroundTaskRetryPresentation(task = {}) {
+function backgroundTaskRetryPresentation(task = {}, session = {}) {
+  if (
+    normalizeText(task.id) === CODEX_BOOTSTRAP_TASK_ID &&
+    normalizeText(task.status) === "failed" &&
+    !sessionHasWorktree(session)
+  ) {
+    return null;
+  }
   const retry = isPlainObject(task.retry) ? task.retry : null;
   if (!retry) {
     return null;
@@ -848,7 +948,7 @@ function backgroundTaskPresentation(session = {}) {
         kind: normalizeText(task.kind),
         label: normalizeText(task.label) || id,
         message: normalizeText(task.message),
-        retry: backgroundTaskRetryPresentation(task),
+        retry: backgroundTaskRetryPresentation(task, session),
         startedAt: normalizeText(task.startedAt),
         status,
         terminalSessionId: normalizeText(task.terminalSessionId),
@@ -865,6 +965,12 @@ function buildPresentation(session = {}) {
   const kind = normalizeText(autopilot.kind);
   let base = interaction || waiting;
 
+  if (!base && autopilot.stop === true && stopPresentationPersistsWhenComplete(session)) {
+    base = stopScreenPresentation(session);
+  }
+  if (!base && stepMachineStatus(session) === STEP_STATUS.DONE && nextIsReady(session)) {
+    base = genericPresentation(session);
+  }
   if (!base && autopilot.userDecision === true) {
     base = userDecisionPresentation(session);
   }
@@ -1070,7 +1176,11 @@ async function runActionIntent(runtime, session = {}, selectedIntent = {}, inten
       "vibe64_intent_not_handled"
     );
   }
-  return runtime.runAction(session.sessionId, actionId, fields);
+  return runtime.runAction(session.sessionId, actionId, {
+    ...(isPlainObject(selectedIntent.submitFields) ? selectedIntent.submitFields : {}),
+    ...(isPlainObject(config.submitFields) ? config.submitFields : {}),
+    ...fields
+  });
 }
 
 async function rejectWorkflowIntent(runtime, session = {}, fields = {}) {
@@ -1227,7 +1337,7 @@ async function runWorkflowIntentHandler(runtime, session = {}, selectedIntent =
 
 async function runBuiltinWorkflowIntent(runtime, session = {}, selectedIntent = {}, intentConfig = {}, fields = {}) {
   const hasIntentConfig = isPlainObject(intentConfig) && Object.keys(intentConfig).length > 0;
-  const type = normalizeText(intentConfig?.type);
+  const type = normalizeText(intentConfig?.type || selectedIntent.operation);
   if (type === "continue") {
     return runtime.advance(session.sessionId);
   }
@@ -1243,6 +1353,20 @@ async function runBuiltinWorkflowIntent(runtime, session = {}, selectedIntent =
   );
 }
 
+async function withIntentAuditMessage(runtime, session = {}, selectedIntent = {}, resultSession = {}) {
+  const auditMessage = normalizeText(selectedIntent.auditMessage);
+  if (!auditMessage || typeof runtime?.store?.writeConversationUserMessage !== "function") {
+    return resultSession;
+  }
+  await runtime.store.writeConversationUserMessage(session.sessionId, {
+    text: auditMessage
+  });
+  return {
+    ...await runtime.getSession(session.sessionId),
+    ...(resultSession?.actionResult ? { actionResult: resultSession.actionResult } : {})
+  };
+}
+
 async function runWorkflowIntent(runtime, sessionId = "", intentId = "", input = {}) {
   const session = await runtime.getSession(sessionId);
   const normalizedIntentId = normalizeText(intentId);
@@ -1261,18 +1385,21 @@ async function runWorkflowIntent(runtime, sessionId = "", intentId = "", input =
   }
   assertIntentMatchesCurrentState(session, input);
 
-  const fields = intentFields(input);
+  const intentConfig = intentConfigForIntent(runtime, session, normalizedIntentId);
+  const fields = {
+    ...(isPlainObject(selectedIntent.submitFields) ? selectedIntent.submitFields : {}),
+    ...(isPlainObject(intentConfig?.submitFields) ? intentConfig.submitFields : {}),
+    ...intentFields(input)
+  };
   const handledSession = await runWorkflowIntentHandler(runtime, session, selectedIntent, fields);
-  if (handledSession) {
-    return handledSession;
-  }
-  return runBuiltinWorkflowIntent(
+  const resultSession = handledSession || await runBuiltinWorkflowIntent(
     runtime,
     session,
     selectedIntent,
-    intentConfigForIntent(runtime, session, normalizedIntentId),
+    intentConfig,
     fields
   );
+  return withIntentAuditMessage(runtime, session, selectedIntent, resultSession);
 }
 
 export {

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

@@ -33,6 +33,12 @@ const STEP_INPUT_KIND = Object.freeze({
   WAITING_FOR_INPUT: "waiting_for_input"
 });
 
+const LET_CODEX_DECIDE_INPUT = Object.freeze({
+  id: "let_codex_decide",
+  label: "Let Codex decide",
+  message: "You decide."
+});
+
 function machineState(status, details = {}) {
   return {
     ...details,
@@ -200,24 +206,25 @@ function artifactText(value = "") {
 }
 
 function commandFailureInteraction({
-  prompt = "The command failed. Explain what should happen, then retry the command.",
+  prompt = "The command failed. Fix anything needed, then retry the command.",
   title = "Command needs attention"
 } = {}) {
   return {
     fields: [
       {
         kind: "textarea",
-        label: "What should happen next?",
+        label: "Retry note",
         name: "response",
-        required: true,
-        requiredMessage: "Explain what should happen before retrying.",
+        placeholder: "Optional note about what changed before retrying.",
+        required: false,
+        rows: 3,
         value: ""
       }
     ],
     kind: "command_failure_response",
     prompt,
     submitKind: STEP_INPUT_KIND.USER_RESPONSE,
-    submitLabel: "Save response",
+    submitLabel: "Retry command",
     title
   };
 }
@@ -225,9 +232,18 @@ function commandFailureInteraction({
 function promptWaitingForInputInteraction({
   actionId = "",
   prompt = "Codex needs more information before this step can continue.",
+  skipInput = null,
   submitLabel = "Send to Codex",
   title = "Talk to Codex"
 } = {}) {
+  const normalizedSkipInput = skipInput && typeof skipInput === "object" && !Array.isArray(skipInput)
+    ? {
+        id: normalizeText(skipInput.id || "let_codex_decide"),
+        label: normalizeText(skipInput.label || "Let Codex decide"),
+        message: normalizeText(skipInput.message),
+        style: normalizeText(skipInput.style || "secondary")
+      }
+    : null;
   return {
     actionId: normalizeText(actionId),
     fields: [
@@ -243,6 +259,7 @@ function promptWaitingForInputInteraction({
     intentId: "talk_to_codex",
     kind: "conversation",
     prompt,
+    ...(normalizedSkipInput?.message ? { skipInput: normalizedSkipInput } : {}),
     submitKind: "",
     submitLabel,
     title
@@ -314,6 +331,16 @@ function promptActionIsReadyForDone(input = {}) {
   return input.kind === STEP_INPUT_KIND.READY || input.kind === STEP_INPUT_KIND.CONSIDER_RESOLVED;
 }
 
+function inputIsStructuredCompletion(input = {}) {
+  return input.kind === STEP_INPUT_KIND.READY || input.kind === STEP_INPUT_KIND.CONFIRM_FILES;
+}
+
+function configuredCompletionMessage(completionMessage, context = {}, input = {}) {
+  return normalizeText(typeof completionMessage === "function"
+    ? completionMessage(context, input)
+    : completionMessage);
+}
+
 async function writePromptResponseArtifact(context = {}, artifactName = "", text = "") {
   const normalizedArtifact = normalizeText(artifactName);
   if (!normalizedArtifact) {
@@ -331,12 +358,13 @@ function promptStepDoneView(context = {}, machine = {}, state = {}) {
   };
 }
 
-function promptStepWaitingForInputView(context = {}, machine = {}, state = {}) {
+function promptStepWaitingForInputView(context = {}, machine = {}, state = {}, options = {}) {
   return {
     interaction: promptWaitingForInputInteraction({
-      actionId: machine.promptActionId,
-      prompt: state.message || "Codex needs more information before this step can continue.",
-      title: "Talk to Codex"
+      actionId: normalizeText(options.actionId || state.promptActionId || machine.promptActionId),
+      prompt: options.prompt || state.message || "Codex needs more information before this step can continue.",
+      skipInput: options.skipInput,
+      title: options.title || "Talk to Codex"
     }),
     next: nextForSession(context.session, {
       disabledReason: "Answer Codex before continuing."
@@ -383,6 +411,7 @@ function chatWithAiPromptInstructionOptions({
 }
 
 function createChatWithAiMachine({
+  completionMessage = "Conversation turn completed.",
   completionPolicy = {},
   nextWhenIdle = {
     enabled: true
@@ -430,6 +459,13 @@ function createChatWithAiMachine({
       });
     },
 
+    inputCompletionMessage(context = {}) {
+      const input = normalizeMachineInput(context.input);
+      return promptActionIsReadyForDone(input)
+        ? configuredCompletionMessage(completionMessage, context, input)
+        : "";
+    },
+
     async actionStarted(context = {}) {
       return markPromptActionStarted(context, this, normalizedPromptActionId, {
         restartDone: true
@@ -455,6 +491,7 @@ function optionalActionsView(context = {}, state = {}, actionConfig = null) {
 // show those fields for user confirmation, then optionally wait for a command.
 function createEditableArtifactReviewMachine({
   command = null,
+  completionMessage = "Draft submitted for review.",
   done,
   draftOrigin = "user",
   draftReady,
@@ -689,6 +726,13 @@ function createEditableArtifactReviewMachine({
         : command.failureState(context, state));
     },
 
+    inputCompletionMessage(context = {}) {
+      const input = normalizeMachineInput(context.input);
+      return inputIsStructuredCompletion(input)
+        ? configuredCompletionMessage(completionMessage, context, input)
+        : "";
+    },
+
     ...(typeof promptInstruction === "function" ? { promptInstruction } : {})
   };
 }
@@ -728,8 +772,15 @@ async function handleStandardPromptInput(context = {}, machine = {}, {
         if (responseArtifact) {
           await writePromptResponseArtifact(context, responseArtifact, input.fields.response || input.text);
         }
+        const completionMessage = normalizeText(input.message) ||
+          (typeof machine.inputCompletionMessage === "function"
+            ? normalizeText(machine.inputCompletionMessage({
+                input,
+                ...context
+              }))
+            : "");
         await writeState(context, machine, machineState(STEP_STATUS.DONE, {
-          message: input.message,
+          message: completionMessage,
           source: input.source
         }));
         return;
@@ -903,6 +954,7 @@ function commandStepView(context = {}, machine = {}, state = {}, {
 }
 
 export {
+  LET_CODEX_DECIDE_INPUT,
   STEP_INPUT_KIND,
   STEP_STATUS,
   actionCompleted,
@@ -935,5 +987,6 @@ export {
   submitCommandFailureInput,
   unsupportedInputKind,
   writeCommandActionFinishedState,
+  writePromptResponseArtifact,
   writeState
 };