vibe64 0.1.21 → 0.1.22

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

@@ -43,6 +43,7 @@ function optionalContextLine(label, value) {
 function terminalFailureFixPrompt({
   actionId = "",
   actionLabel = "",
+  attemptedCommand = "",
   closeError = "",
   commandPreview = "",
   currentStep = "",
@@ -79,6 +80,7 @@ function terminalFailureFixPrompt({
     optionalContextLine("Status", terminalStatus),
     optionalContextLine("Exit code", exitCode),
     optionalContextLine("Error", closeError),
+    optionalContextLine("Attempted command", attemptedCommand),
     optionalContextLine("Command", commandPreview)
   ].filter(Boolean).join("\n");
 
@@ -125,6 +127,114 @@ function terminalFailureFixRequest(input = {}) {
   };
 }
 
+function projectToolDeployRepairInstructions(toolId = "") {
+  if (!["push_to_production", "push_to_staging"].includes(normalizeText(toolId))) {
+    return [];
+  }
+  return [
+    "This deploy tool runs a command saved in Vibe64 project configuration.",
+    "Treat the exact Attempted command as authoritative. Do not replace or rewrite the saved deploy command just because it exited non-zero.",
+    "Only change repository files when the attempted command failed because of a clear repository-owned defect.",
+    "If the attempted command itself is a placeholder, intentionally failing command, missing external credentials, remote access issue, or otherwise needs user intent, report `blocked` through the callback instead of editing config/code."
+  ];
+}
+
+function sessionTerminalFailureFixPrompt(input = {}) {
+  const outputTail = terminalFailureOutputTail(input.output);
+  const subject = describeTerminalFailureSubject({
+    actionId: input.actionId,
+    actionLabel: input.actionLabel,
+    launchTargetId: input.launchTargetId,
+    launchTargetLabel: input.launchTargetLabel,
+    shellTarget: input.shellTarget,
+    terminalKind: input.terminalKind
+  });
+  const contextLines = [
+    optionalContextLine("Scope", "session"),
+    optionalContextLine("Session", input.sessionId),
+    optionalContextLine("Current step", input.currentStep),
+    optionalContextLine("Step status", input.stepStatus),
+    optionalContextLine("Target root", input.targetRoot),
+    optionalContextLine("Worktree", input.worktreePath),
+    optionalContextLine("Terminal kind", input.terminalKind),
+    optionalContextLine("Terminal session", input.terminalSessionId),
+    optionalContextLine("Subject", subject),
+    optionalContextLine("Action id", input.actionId),
+    optionalContextLine("Launch target id", input.launchTargetId),
+    optionalContextLine("Shell target", input.shellTarget),
+    optionalContextLine("Status", input.terminalStatus),
+    optionalContextLine("Exit code", input.exitCode),
+    optionalContextLine("Error", input.closeError),
+    optionalContextLine("Attempted command", input.attemptedCommand),
+    optionalContextLine("Command", input.commandPreview)
+  ].filter(Boolean).join("\n");
+
+  return [
+    "A Vibe64 session terminal failed. Diagnose the failure from the repository and terminal output, then attempt to fix the underlying cause in the session worktree.",
+    "This is an ephemeral repair job, not a chat. Do not use the session Codex terminal or global Codex terminal for this repair.",
+    "Leave any code/config changes in the session worktree. When the repair is complete or blocked, report through the Fix Codex callback helper.",
+    "Before editing, inspect the session diff against its base branch. Only repair failures that are plausibly caused by this session's requested work or existing session diff.",
+    "If the failed command exposes an unrelated baseline repository failure, missing external dependency, broken local service, or broad issue outside the session diff, do not repair unrelated files. Report `blocked` through the callback with the retry blocker and the exact command that failed.",
+    "",
+    "Terminal context:",
+    contextLines || "- No terminal metadata was available.",
+    "",
+    "User note:",
+    normalizeText(input.userMessage) || "(No extra note was provided.)",
+    "",
+    `Last ${DEFAULT_TERMINAL_FAILURE_TAIL_LINES} terminal lines:`,
+    "~~~text",
+    outputTail || "(No terminal output was captured.)",
+    "~~~"
+  ].join("\n");
+}
+
+function projectToolFailureFixPrompt(input = {}, {
+  reportInstructions = ""
+} = {}) {
+  const toolId = input.toolId || input.actionId;
+  const outputTail = terminalFailureOutputTail(input.output);
+  const subject = describeTerminalFailureSubject({
+    actionId: toolId,
+    actionLabel: input.toolLabel || input.actionLabel,
+    terminalKind: "project_tool"
+  });
+  const contextLines = [
+    optionalContextLine("Scope", "project"),
+    optionalContextLine("Target root", input.targetRoot),
+    optionalContextLine("Tool id", input.toolId || input.actionId),
+    optionalContextLine("Tool label", input.toolLabel || input.actionLabel),
+    optionalContextLine("Subject", subject),
+    optionalContextLine("Terminal session", input.terminalSessionId),
+    optionalContextLine("Status", input.terminalStatus),
+    optionalContextLine("Exit code", input.exitCode),
+    optionalContextLine("Error", input.closeError),
+    optionalContextLine("Attempted command", input.attemptedCommand),
+    optionalContextLine("Command", input.commandPreview)
+  ].filter(Boolean).join("\n");
+
+  return [
+    "A project-level Vibe64 tool failed. Diagnose the failure from the repository and terminal output, then attempt to fix the underlying cause in the main project checkout.",
+    "This is an ephemeral repair job, not a chat. Do not use or modify Vibe64 session state unless the failure itself requires a repository code/config change.",
+    "The Terminal context includes the exact Attempted command. Start from that command, not from the tool label alone.",
+    "If the exact Attempted command is itself invalid, intentionally failing, or depends on missing external/user configuration, do not guess a replacement command. Report `blocked` with the command and the reason.",
+    ...projectToolDeployRepairInstructions(toolId),
+    "",
+    reportInstructions,
+    "",
+    "Terminal context:",
+    contextLines || "- No terminal metadata was available.",
+    "",
+    "User note:",
+    normalizeText(input.userMessage) || "(No extra note was provided.)",
+    "",
+    `Last ${DEFAULT_TERMINAL_FAILURE_TAIL_LINES} terminal lines:`,
+    "~~~text",
+    outputTail || "(No terminal output was captured.)",
+    "~~~"
+  ].filter((line) => line !== "").join("\n");
+}
+
 function terminalFailureFixRequestForSession(session = {}, input = {}) {
   return terminalFailureFixRequest({
     ...input,
@@ -136,6 +246,8 @@ function terminalFailureFixRequestForSession(session = {}, input = {}) {
 
 export {
   DEFAULT_TERMINAL_FAILURE_TAIL_LINES,
+  projectToolFailureFixPrompt,
+  sessionTerminalFailureFixPrompt,
   terminalFailureFixPrompt,
   terminalFailureFixRequest,
   terminalFailureFixRequestForSession,

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

@@ -2,8 +2,8 @@ const HUMAN_INPUT_RESPONSE_ARTIFACT = "response.md";
 const ISSUE_BODY_ARTIFACT = "issue.md";
 const ISSUE_TITLE_ARTIFACT = "issue_title";
 const ISSUE_WORD_ARTIFACT = "issue_word";
-const PULL_REQUEST_BODY_DRAFT_ARTIFACT = "tmp/create_pull_request.body.md";
-const PULL_REQUEST_TITLE_DRAFT_ARTIFACT = "tmp/create_pull_request.title.txt";
+const PULL_REQUEST_BODY_DRAFT_ARTIFACT = "tmp/create_and_merge_pull_request.body.md";
+const PULL_REQUEST_TITLE_DRAFT_ARTIFACT = "tmp/create_and_merge_pull_request.title.txt";
 const REPORT_ARTIFACT = "report.md";
 
 export {

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

@@ -68,6 +68,7 @@ function buildAgentConversationStepDefinition({
             type: "continue"
           }
         ],
+        persistWhenComplete: true,
         screen: {
           kind: "conversation",
           message: "Ask Codex for changes. Continue when the work is ready for the next workflow step.",

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

@@ -0,0 +1,192 @@
+import {
+  vibe64Error,
+  isPlainObject,
+  normalizeText,
+  plainClone
+} from "@local/vibe64-core/server/core";
+import { deepFreeze } from "@local/vibe64-core/server/deepFreeze";
+
+const WORKFLOW_DEFINITION_PART_KIND = "workflow_definition_part";
+
+function cloneStepEntry(entry) {
+  return typeof entry === "string" ? normalizeText(entry) : plainClone(entry);
+}
+
+function emptyExpansion() {
+  return {
+    intentHandlers: {},
+    steps: []
+  };
+}
+
+function normalizeIntentHandlers(intentHandlers = {}, context = "") {
+  if (intentHandlers === undefined || intentHandlers === null) {
+    return {};
+  }
+  if (!isPlainObject(intentHandlers)) {
+    throw vibe64Error(
+      `Vibe64 workflow ${context} intentHandlers must be an object.`,
+      "vibe64_workflow_definition_part_invalid"
+    );
+  }
+
+  const normalizedHandlers = {};
+  for (const [rawStepId, stepHandlers] of Object.entries(intentHandlers)) {
+    const stepId = normalizeText(rawStepId);
+    if (!stepId) {
+      throw vibe64Error(
+        `Vibe64 workflow ${context} intentHandlers contains an empty step id.`,
+        "vibe64_workflow_definition_part_invalid"
+      );
+    }
+    if (!isPlainObject(stepHandlers)) {
+      throw vibe64Error(
+        `Vibe64 workflow ${context} intentHandlers.${stepId} must be an object.`,
+        "vibe64_workflow_definition_part_invalid"
+      );
+    }
+
+    normalizedHandlers[stepId] = {};
+    for (const [rawIntentId, handler] of Object.entries(stepHandlers)) {
+      const intentId = normalizeText(rawIntentId);
+      if (!intentId || typeof handler !== "function") {
+        throw vibe64Error(
+          `Vibe64 workflow ${context} intentHandlers.${stepId}.${intentId || "(empty)"} must be a function.`,
+          "vibe64_workflow_definition_part_invalid"
+        );
+      }
+      normalizedHandlers[stepId][intentId] = handler;
+    }
+  }
+  return normalizedHandlers;
+}
+
+function mergeWorkflowIntentHandlers(handlerSets = [], context = "") {
+  const merged = {};
+  for (const handlerSet of handlerSets) {
+    const sourceHandlers = normalizeIntentHandlers(handlerSet, context);
+    for (const [stepId, stepHandlers] of Object.entries(sourceHandlers)) {
+      merged[stepId] = merged[stepId] || {};
+      for (const [intentId, handler] of Object.entries(stepHandlers)) {
+        if (Object.hasOwn(merged[stepId], intentId)) {
+          throw vibe64Error(
+            `Vibe64 workflow ${context} has duplicate intent handler: ${stepId}.${intentId}.`,
+            "vibe64_workflow_duplicate_intent_handler"
+          );
+        }
+        merged[stepId][intentId] = handler;
+      }
+    }
+  }
+  return merged;
+}
+
+function isWorkflowDefinitionPart(part = {}) {
+  return isPlainObject(part) && part.kind === WORKFLOW_DEFINITION_PART_KIND;
+}
+
+function expandWorkflowPart(part, context = "") {
+  if (!part) {
+    return emptyExpansion();
+  }
+  if (Array.isArray(part)) {
+    return expandWorkflowParts(part, context);
+  }
+  if (isWorkflowDefinitionPart(part)) {
+    return {
+      intentHandlers: normalizeIntentHandlers(part.intentHandlers, `${context} ${part.id}`.trim()),
+      steps: (Array.isArray(part.steps) ? part.steps : []).map(cloneStepEntry)
+    };
+  }
+  if (typeof part === "string" || isPlainObject(part)) {
+    return {
+      intentHandlers: {},
+      steps: [cloneStepEntry(part)]
+    };
+  }
+  throw vibe64Error(
+    `Vibe64 workflow ${context} contains an invalid workflow definition part.`,
+    "vibe64_workflow_definition_part_invalid"
+  );
+}
+
+function expandWorkflowParts(parts = [], context = "") {
+  const expansion = emptyExpansion();
+  for (const part of Array.isArray(parts) ? parts : [parts]) {
+    const partExpansion = expandWorkflowPart(part, context);
+    expansion.steps.push(...partExpansion.steps);
+    expansion.intentHandlers = mergeWorkflowIntentHandlers([
+      expansion.intentHandlers,
+      partExpansion.intentHandlers
+    ], context);
+  }
+  return expansion;
+}
+
+function workflowGroup({
+  id = "",
+  intentHandlers = {},
+  steps = []
+} = {}) {
+  const groupId = normalizeText(id);
+  if (!groupId) {
+    throw vibe64Error(
+      "Vibe64 workflow groups require an id.",
+      "vibe64_workflow_definition_part_invalid"
+    );
+  }
+
+  const expansion = expandWorkflowParts(steps, `group ${groupId}`);
+  return deepFreeze({
+    id: groupId,
+    intentHandlers: mergeWorkflowIntentHandlers([
+      expansion.intentHandlers,
+      intentHandlers
+    ], `group ${groupId}`),
+    kind: WORKFLOW_DEFINITION_PART_KIND,
+    steps: expansion.steps
+  });
+}
+
+function workflowWhen(condition, part) {
+  return condition ? part : null;
+}
+
+function defineWorkflow(definition = {}) {
+  const definitionObject = isPlainObject(definition) ? definition : {};
+  const workflowId = normalizeText(definitionObject.id);
+  if (!workflowId) {
+    throw vibe64Error(
+      "Vibe64 workflow definitions require an id.",
+      "vibe64_workflow_definition_invalid"
+    );
+  }
+  if (Object.hasOwn(definitionObject, "steps") && Object.hasOwn(definitionObject, "parts")) {
+    throw vibe64Error(
+      `Vibe64 workflow ${workflowId} cannot define both steps and parts.`,
+      "vibe64_workflow_definition_invalid"
+    );
+  }
+
+  const expansion = expandWorkflowParts(
+    Object.hasOwn(definitionObject, "parts") ? definitionObject.parts : definitionObject.steps,
+    `workflow ${workflowId}`
+  );
+  const workflow = {
+    ...definitionObject,
+    id: workflowId,
+    intentHandlers: mergeWorkflowIntentHandlers([
+      expansion.intentHandlers,
+      definitionObject.intentHandlers
+    ], `workflow ${workflowId}`),
+    steps: expansion.steps
+  };
+  delete workflow.parts;
+  return deepFreeze(workflow);
+}
+
+export {
+  defineWorkflow,
+  workflowGroup,
+  workflowWhen
+};

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

@@ -255,6 +255,7 @@ function normalizeAction(action = {}, stepId = "") {
   const type = normalizeText(action.type || "command");
   return {
     adapterCapability: normalizeText(action.adapterCapability),
+    auditMessage: normalizeText(action.auditMessage),
     advanceOnSuccess: action.advanceOnSuccess === true,
     disabledReason: normalizeText(action.disabledReason),
     disabledWhenReason: normalizeText(action.disabledWhenReason || action.disabledReason),
@@ -268,6 +269,7 @@ function normalizeAction(action = {}, stepId = "") {
     label: normalizeText(action.label || id),
     promptId: type === "prompt" ? normalizeText(action.promptId || id) : "",
     recordsConversationTurn: action.recordsConversationTurn === true,
+    saveCurrentStepInputBeforeRun: action.saveCurrentStepInputBeforeRun === true,
     type,
     visible: action.visible !== false
   };
@@ -551,6 +553,9 @@ function publicActionDefinition(action) {
   if (action.recordsConversationTurn) {
     definition.recordsConversationTurn = true;
   }
+  if (action.saveCurrentStepInputBeforeRun) {
+    definition.saveCurrentStepInputBeforeRun = true;
+  }
   if (action.inputFields.length > 0) {
     definition.inputFields = action.inputFields.map((field) => ({
       ...field