metheus-governance-mcp-cli 0.2.146 → 0.2.147

package/cli.mjs

@@ -14,6 +14,7 @@ import {
   analyzeHumanConversationIntentWithAI,
   auditDirectHumanReplyWithAI,
   normalizeExecutionArtifacts,
+  planRoleExecutionWithAI,
   resolveLocalAIExecutionModel,
   resolveGeminiReasoningConfig,
   suggestLocalAIModelDisplayName,
@@ -143,6 +144,7 @@ import {
 } from "./lib/runner-delivery.mjs";
 import {
   resolveRunnerExecutionPlan,
+  resolveRunnerExecutionPlanForRole,
   resolveRunnerRoleProfile,
   resolveRunnerWorkspaceSelection,
   runRunnerAIExecution,
@@ -3000,16 +3002,19 @@ function buildRunnerExecutionDeps() {
   return {
     analyzeHumanConversationIntentWithAI,
     auditDirectHumanReplyWithAI,
+    planRoleExecutionWithAI,
     normalizeRunnerRoleProfileName,
     normalizeRunnerRoleProfile,
     normalizeBotRunnerProjectMapping,
     sanitizeWorkspaceCandidate,
     loadProviderEnvConfig,
+    loadBotRunnerConfig,
     canUseLegacyRunnerCommand,
     hasLegacyRunnerCommand,
     isLegacyRunnerCommandOptInEnabled,
     legacyRunnerCommandDisabledMessage,
     normalizeExecutionArtifacts,
+    resolveRunnerExecutionPlanForRole,
     validateWorkspaceArtifacts,
     tryJsonParse,
   };

package/lib/local-ai-adapters.mjs

@@ -718,6 +718,50 @@ function normalizeExecutionContract(rawContract) {
   };
 }
 
+const RUNNER_EXECUTION_STEP_ROLES = new Set(["monitor", "worker", "review", "approval"]);
+
+function normalizeRoleExecutionStepRole(rawValue) {
+  const normalized = String(rawValue || "").trim().toLowerCase();
+  return RUNNER_EXECUTION_STEP_ROLES.has(normalized) ? normalized : "";
+}
+
+function normalizeRoleExecutionStep(rawStep) {
+  const step = safeObject(rawStep);
+  const role = normalizeRoleExecutionStepRole(step.role || step.profile || step.role_profile || step.roleProfile);
+  const goal = firstNonEmptyString([
+    step.goal,
+    step.task,
+    step.objective,
+    step.description,
+  ]);
+  if (!role || !goal) {
+    return null;
+  }
+  return {
+    role,
+    goal,
+    artifactsRequired: step.artifacts_required === true || step.artifactsRequired === true,
+  };
+}
+
+export function normalizeRoleExecutionPlan(rawPlan) {
+  const plan = safeObject(rawPlan);
+  if (!Object.keys(plan).length) {
+    return null;
+  }
+  const steps = ensureArray(plan.steps)
+    .map((item) => normalizeRoleExecutionStep(item))
+    .filter(Boolean);
+  const summaryRole = normalizeRoleExecutionStepRole(plan.summary_role || plan.summaryRole);
+  const requiresExecution = plan.requires_execution === true || plan.requiresExecution === true;
+  return {
+    requiresExecution,
+    summaryRole: summaryRole || (steps.length > 0 ? steps[steps.length - 1].role : ""),
+    steps,
+    reason: String(plan.reason || "").trim(),
+  };
+}
+
 function normalizeModelAliasText(rawValue) {
   return String(rawValue || "")
     .trim()
@@ -1070,6 +1114,7 @@ function inferCurrentTurnPurpose({ trigger, conversation, selfBotUsername, other
 
 export function buildLocalBotPrompt(payload, { terse = true } = {}) {
   const safePayload = payload && typeof payload === "object" ? payload : {};
+  const taskName = String(safePayload.task || "").trim();
   const trigger = safePayload.trigger && typeof safePayload.trigger === "object" ? safePayload.trigger : {};
   const responseContract = safePayload.response_contract && typeof safePayload.response_contract === "object"
     ? safePayload.response_contract
@@ -1156,9 +1201,14 @@ export function buildLocalBotPrompt(payload, { terse = true } = {}) {
   const assignmentsForThisBot = currentExecutionAssignments.filter((item) => (
     String(item.target_bot || item.targetBot || "").trim().replace(/^@+/, "").toLowerCase() === selfSelector.toLowerCase()
   ));
+  const executionStep = safeObject(safePayload.execution_step);
+  const executionPlan = safeObject(safePayload.execution_plan);
+  const executionProgress = safeObject(safePayload.execution_progress);
+  const isInternalExecutionStep = taskName === "execute_project_role_step";
 
   const lines = [
     "You are a Metheus local bot runner.",
+    `Task: ${taskName || "reply_to_project_chat_message"}`,
     `Provider: ${provider}`,
     `Role: ${role}`,
     `Role Profile: ${roleProfile || "-"}`,
@@ -1189,6 +1239,32 @@ export function buildLocalBotPrompt(payload, { terse = true } = {}) {
     recentBotMessages.length ? recentBotMessages.map(formatContextCommentLine).join("\n") : "- none",
     "",
   ];
+  if (isInternalExecutionStep) {
+    const stepIndex = intFromRawAllowZero(executionStep.index, 0);
+    const stepTotal = intFromRawAllowZero(executionStep.total, 0);
+    const stepRole = firstNonEmptyString([executionStep.role, roleProfile, role]);
+    const stepGoal = String(executionStep.goal || "").trim();
+    const priorArtifacts = ensureArray(executionProgress.produced_artifacts)
+      .map((item) => firstNonEmptyString([safeObject(item).relativePath, safeObject(item).path]))
+      .filter(Boolean);
+    lines.push(
+      "Internal execution step is active.",
+      "This is not a placeholder chat reply task. Complete the assigned step now.",
+      `Execution Step: ${stepIndex > 0 ? stepIndex : "-"} / ${stepTotal > 0 ? stepTotal : "-"}`,
+      `Execution Step Role: ${stepRole || "-"}`,
+      `Execution Step Goal: ${stepGoal || "-"}`,
+      `Execution Step Requires Artifacts: ${executionStep.artifacts_required === true || executionStep.artifactsRequired === true ? "yes" : "no"}`,
+      `Execution Plan Requires Execution: ${executionPlan.requires_execution === true || executionPlan.requiresExecution === true ? "yes" : "no"}`,
+      `Execution Plan Summary Role: ${String(executionPlan.summary_role || executionPlan.summaryRole || "").trim() || "-"}`,
+      `Prior Produced Artifacts: ${priorArtifacts.length ? priorArtifacts.join(", ") : "-"}`,
+      "Do the work for this step now. Do not say you will start later, wait, come back later, or plan first.",
+      "If this is a worker step, actually create/update the required project artifacts now and include them in artifacts.",
+      "If this is a review step, provide the review findings now.",
+      "If this is an approval step, provide the approval decision now.",
+      "If this is the final step, the reply will be shown to humans. If it is not the final step, the reply is still an internal execution note and must describe what was actually completed in this step.",
+      "",
+    );
+  }
   if (responseContract.must_reply === true) {
     lines.push(
       "This bot was explicitly addressed by the trigger message.",
@@ -1232,7 +1308,9 @@ export function buildLocalBotPrompt(payload, { terse = true } = {}) {
     "- If no project files changed, return artifacts: [].",
     "- Do not claim that a file, plan, document, or code change is complete unless the corresponding artifact path is present in artifacts.",
     "",
-    responseContract.must_reply === true
+    isInternalExecutionStep
+      ? "Return JSON only in one line: {\"reply\":\"what was completed in this step\",\"artifacts\":[{\"path\":\"relative/or/absolute/path\",\"kind\":\"plan|code|doc|spec|test\",\"operation\":\"create|update|delete\"}],\"contract\":{\"type\":\"direct_result|summary_request|final_summary\",\"actionable\":true,\"summary_bot\":\"username\",\"next_responders\":[\"username\"]}}. Use artifacts: [] only if this step truly changes no project files."
+      : responseContract.must_reply === true
       ? "Return JSON only in one line: {\"reply\":\"...\",\"artifacts\":[]} or {\"reply\":\"...\",\"artifacts\":[],\"contract\":{\"type\":\"direct_result|delegation|summary_request|final_summary\",\"actionable\":true,\"assignments\":[{\"target_bot\":\"username\",\"task\":\"...\"}],\"summary_bot\":\"username\",\"next_responders\":[\"username\"]}}."
       : terse
         ? "Return JSON only in one line: {\"reply\":\"...\",\"artifacts\":[]} or {\"skip\":true,\"reason\":\"...\"}."
@@ -1426,6 +1504,57 @@ function buildConversationIntentAnalysisPrompt({
   ].join("\n");
 }
 
+function buildRoleExecutionPlanPrompt({
+  messageText,
+  currentBotUsername,
+  currentBotRole,
+  managedBots,
+  workspaceDir,
+  currentAssignmentTasks = [],
+  contextComments = [],
+  conversationMode = "",
+}) {
+  const bots = ensureArray(managedBots).map((item) => {
+    const bot = safeObject(item);
+    return {
+      username: String(bot.username || "").trim().replace(/^@+/, ""),
+      display_name: String(bot.display_name || bot.displayName || bot.username || "").trim(),
+    };
+  }).filter((item) => item.username);
+  const normalizedContext = ensureArray(contextComments)
+    .slice(0, 10)
+    .map((item) => formatContextCommentLine(item));
+  return [
+    "You are an execution planner for managed local Telegram bots.",
+    "Read the human request and recent room context, then decide whether actual project execution is required now.",
+    "Judge by meaning, not by keywords or @mentions alone.",
+    "If the request only asks for status, explanation, location, or clarification, then requires_execution should be false.",
+    "If the request asks the bot to create/update/delete project files, write plans/docs/code, delegate concrete tasks, continue execution, or otherwise do work now, then requires_execution should be true.",
+    "When requires_execution=true, return the minimal role step plan using only these roles: monitor, worker, review, approval.",
+    "Role guidance:",
+    "- monitor: understand context, scope the work, plan, coordinate, or summarize.",
+    "- worker: actually create/update/delete project artifacts now.",
+    "- review: inspect completed work and report findings, issues, or improvements.",
+    "- approval: make a go/no-go, approval, or explicit decision when the request calls for it.",
+    "worker is required if project artifacts must be created or updated now.",
+    "review is required if the request implies checking or validating the created result before finalizing.",
+    "approval is required only when the request asks for approval, release, confirmation, or a formal decision.",
+    "",
+    "Return strict JSON only with this shape:",
+    "{\"requires_execution\":true|false,\"summary_role\":\"monitor|worker|review|approval\",\"reason\":\"short explanation\",\"steps\":[{\"role\":\"monitor|worker|review|approval\",\"goal\":\"short goal\",\"artifacts_required\":true|false}]}",
+    "",
+    `current_bot_username=${JSON.stringify(String(currentBotUsername || "").trim().replace(/^@+/, ""))}`,
+    `current_bot_route_role=${JSON.stringify(String(currentBotRole || "").trim().toLowerCase())}`,
+    `conversation_mode=${JSON.stringify(String(conversationMode || "").trim())}`,
+    `workspace_dir=${JSON.stringify(String(workspaceDir || "").trim())}`,
+    `managed_bots=${JSON.stringify(bots)}`,
+    `current_assignment_tasks=${JSON.stringify(ensureArray(currentAssignmentTasks).map((item) => String(item || "").trim()).filter(Boolean))}`,
+    `human_message=${JSON.stringify(String(messageText || "").trim())}`,
+    "recent_context=",
+    normalizedContext.length ? normalizedContext.join("\n") : "- none",
+  ].join("\n");
+}
+
 function buildDirectReplyGuardrailPrompt({
   humanMessageText,
   botReplyText,
@@ -1557,6 +1686,59 @@ export function auditDirectHumanReplyWithAI({
   };
 }
 
+export function planRoleExecutionWithAI({
+  messageText,
+  currentBotUsername,
+  currentBotRole = "",
+  managedBots,
+  workspaceDir,
+  currentAssignmentTasks = [],
+  contextComments = [],
+  conversationMode = "",
+  client = "",
+  model = "",
+  env = process.env,
+}) {
+  const bots = ensureArray(managedBots);
+  if (!bots.length) {
+    return null;
+  }
+  const plannerClient = normalizeLocalAIClientName(
+    String(client || env?.METHEUS_ROLE_PLANNER_CLIENT || env?.METHEUS_INTENT_PARSER_CLIENT || "").trim(),
+    "gpt",
+  );
+  const plannerModel = String(
+    model
+    || env?.METHEUS_ROLE_PLANNER_MODEL
+    || env?.METHEUS_INTENT_PARSER_MODEL
+    || suggestLocalAIModelDisplayName(plannerClient, "")
+    || "",
+  ).trim();
+  const rawText = runLocalAIPromptRawText({
+    client: plannerClient,
+    promptText: buildRoleExecutionPlanPrompt({
+      messageText,
+      currentBotUsername,
+      currentBotRole,
+      managedBots: bots,
+      workspaceDir,
+      currentAssignmentTasks,
+      contextComments,
+      conversationMode,
+    }),
+    workspaceDir,
+    model: plannerModel,
+    permissionMode: "read_only",
+    reasoningEffort: String(env?.METHEUS_ROLE_PLANNER_REASONING_EFFORT || "medium").trim() || "medium",
+    env,
+  });
+  const parsed = tryJsonParse(rawText) || tryParseEmbeddedJsonObject(rawText);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("role execution planner did not return a JSON object");
+  }
+  return normalizeRoleExecutionPlan(parsed);
+}
+
 export function runLocalAIClient({
   client,
   inputPayload,

package/lib/runner-execution.mjs

@@ -241,6 +241,23 @@ export function resolveRunnerExecutionPlan(route, bot, config, deps) {
   throw new Error(detail.join("; "));
 }
 
+export function resolveRunnerExecutionPlanForRole(route, bot, roleName, config, deps) {
+  const normalizedRoleName = String(roleName || "").trim().toLowerCase();
+  if (!normalizedRoleName) {
+    throw new Error("roleName is required to resolve a role execution plan");
+  }
+  return resolveRunnerExecutionPlan(
+    {
+      ...safeObject(route),
+      role: normalizedRoleName,
+      roleProfile: normalizedRoleName,
+    },
+    bot,
+    config,
+    deps,
+  );
+}
+
 function buildRunnerExecutionEnv({ route, destination, executionPlan }) {
   return {
     ...process.env,

package/lib/runner-orchestration.mjs

@@ -431,6 +431,406 @@ function buildDirectHumanResponseContract({
     allowedContractTypes,
   };
 }
+
+function extractCurrentAssignmentTasks(conversationContext, currentBotSelector) {
+  const currentSelector = normalizeMentionSelector(currentBotSelector);
+  if (!currentSelector) return [];
+  return ensureArray(safeObject(conversationContext?.executionContract).assignments)
+    .map((item) => safeObject(item))
+    .filter((item) => normalizeMentionSelector(item.targetBot || item.target_bot) === currentSelector)
+    .map((item) => String(item.task || item.instruction || "").trim())
+    .filter(Boolean);
+}
+
+function requiresArtifactsForExecutionStep(step) {
+  const role = String(safeObject(step).role || "").trim().toLowerCase();
+  return safeObject(step).artifactsRequired === true || role === "worker";
+}
+
+function summarizeExecutedRolePlan(plan, stepResults) {
+  return {
+    requires_execution: safeObject(plan).requiresExecution === true,
+    summary_role: String(safeObject(plan).summaryRole || "").trim(),
+    steps: ensureArray(safeObject(plan).steps).map((item, index) => ({
+      index: index + 1,
+      role: String(safeObject(item).role || "").trim(),
+      goal: String(safeObject(item).goal || "").trim(),
+      artifacts_required: safeObject(item).artifactsRequired === true,
+    })),
+    step_results: ensureArray(stepResults).map((item) => ({
+      role: String(safeObject(item).role || "").trim(),
+      goal: String(safeObject(item).goal || "").trim(),
+      artifact_paths: ensureArray(safeObject(item).artifactPaths),
+      artifact_validation: String(safeObject(item).artifactValidation || "").trim(),
+      reply_chars: intFromRawAllowZero(String(safeObject(item).reply || "").length, 0),
+    })),
+  };
+}
+
+function buildRoleExecutionStepPayload({
+  aiPayload,
+  step,
+  stepIndex,
+  stepTotal,
+  stepExecutionPlan,
+  executedPlan,
+  priorStepResults,
+  producedArtifacts,
+}) {
+  return {
+    ...aiPayload,
+    task: "execute_project_role_step",
+    role: String(step.role || "").trim(),
+    requested_role: String(step.role || "").trim(),
+    role_profile: String(stepExecutionPlan.roleProfileName || step.role || "").trim(),
+    execution: {
+      mode: String(stepExecutionPlan.mode || "").trim(),
+      role_profile: String(stepExecutionPlan.roleProfileName || step.role || "").trim(),
+      client: String(stepExecutionPlan.roleProfile?.client || "").trim(),
+      model: String(stepExecutionPlan.roleProfile?.model || "").trim(),
+      permission_mode: String(stepExecutionPlan.roleProfile?.permissionMode || "").trim(),
+      reasoning_effort: String(stepExecutionPlan.roleProfile?.reasoningEffort || "").trim(),
+      workspace_dir: String(stepExecutionPlan.workspaceDir || "").trim(),
+      workspace_source: String(stepExecutionPlan.workspaceSource || "").trim(),
+      command_fallback: stepExecutionPlan.usedCommandFallback === true,
+      dry_run_delivery: Boolean(safeObject(aiPayload.execution).dry_run_delivery),
+    },
+    execution_plan: {
+      requires_execution: safeObject(executedPlan).requiresExecution === true,
+      summary_role: String(safeObject(executedPlan).summaryRole || "").trim(),
+      steps: ensureArray(safeObject(executedPlan).steps).map((item) => ({
+        role: String(safeObject(item).role || "").trim(),
+        goal: String(safeObject(item).goal || "").trim(),
+        artifacts_required: safeObject(item).artifactsRequired === true,
+      })),
+      reason: String(safeObject(executedPlan).reason || "").trim(),
+    },
+    execution_step: {
+      index: stepIndex,
+      total: stepTotal,
+      role: String(step.role || "").trim(),
+      goal: String(step.goal || "").trim(),
+      artifacts_required: safeObject(step).artifactsRequired === true,
+      is_final_step: stepIndex === stepTotal,
+    },
+    execution_progress: {
+      completed_steps: ensureArray(priorStepResults).map((item) => ({
+        role: String(safeObject(item).role || "").trim(),
+        goal: String(safeObject(item).goal || "").trim(),
+        reply: String(safeObject(item).reply || "").trim(),
+        artifact_paths: ensureArray(safeObject(item).artifactPaths),
+      })),
+      produced_artifacts: ensureArray(producedArtifacts).map((item) => ({
+        path: String(safeObject(item).path || "").trim(),
+        relative_path: String(safeObject(item).relativePath || "").trim(),
+        kind: String(safeObject(item).kind || "").trim(),
+        operation: String(safeObject(item).operation || "").trim(),
+      })),
+    },
+    response_contract: {
+      ...safeObject(aiPayload.response_contract),
+      allow_skip: false,
+      must_reply: true,
+      require_actionable_contract: true,
+      allowed_contract_types: ["direct_result", "summary_request", "final_summary"],
+    },
+  };
+}
+
+async function maybeExecuteDynamicRolePlan({
+  aiPayload,
+  routeKey,
+  normalizedRoute,
+  routeState,
+  selectedRecord,
+  pendingOrdered,
+  bot,
+  destination,
+  archiveThread,
+  executionPlan,
+  runtime,
+  executionDeps,
+  triggerDecision,
+  humanIntentContext,
+  conversationContext,
+  saveRunnerRouteState,
+  runRunnerAIExecution,
+  validateWorkspaceArtifacts,
+}) {
+  const planner = typeof executionDeps.planRoleExecutionWithAI === "function"
+    ? executionDeps.planRoleExecutionWithAI
+    : null;
+  const resolveRunnerExecutionPlanForRole = typeof executionDeps.resolveRunnerExecutionPlanForRole === "function"
+    ? executionDeps.resolveRunnerExecutionPlanForRole
+    : null;
+  const loadBotRunnerConfig = typeof executionDeps.loadBotRunnerConfig === "function"
+    ? executionDeps.loadBotRunnerConfig
+    : null;
+  if (!planner || !resolveRunnerExecutionPlanForRole) {
+    return null;
+  }
+  const currentBotSelector = normalizeMentionSelector(bot?.username || bot?.name);
+  const assignmentTasks = extractCurrentAssignmentTasks(conversationContext, currentBotSelector);
+  const shouldPlanExecution = triggerDecision.requiresDirectReply === true || assignmentTasks.length > 0;
+  if (!shouldPlanExecution) {
+    return null;
+  }
+  const peerMap = humanIntentContext?.peerMap instanceof Map
+    ? humanIntentContext.peerMap
+    : buildConversationPeerMap(bot, normalizedRoute, executionDeps);
+  const managedBots = buildConversationParticipantViews(Array.from(peerMap.keys()), peerMap);
+  let executedPlan;
+  try {
+    executedPlan = await planner({
+      messageText: String(safeObject(selectedRecord?.parsedArchive).body || "").trim(),
+      currentBotUsername: String(bot?.username || bot?.name || "").trim(),
+      currentBotRole: String(executionPlan.roleProfileName || normalizedRoute.role || "").trim(),
+      managedBots,
+      workspaceDir: String(executionPlan.workspaceDir || process.cwd()).trim() || process.cwd(),
+      currentAssignmentTasks: assignmentTasks,
+      contextComments: buildRunnerContextWindow(pendingOrdered, selectedRecord, normalizedRoute.contextComments),
+      conversationMode: String(conversationContext?.mode || "").trim(),
+      client: String(executionPlan.roleProfile?.client || "").trim(),
+      model: String(executionPlan.roleProfile?.model || "").trim(),
+    });
+  } catch {
+    return null;
+  }
+  if (!safeObject(executedPlan).requiresExecution) {
+    return null;
+  }
+  const plannedSteps = ensureArray(safeObject(executedPlan).steps).filter((item) => String(safeObject(item).role || "").trim());
+  if (!plannedSteps.length) {
+    const reason = "execution planner required execution but did not return any executable steps";
+    saveRunnerRouteState(
+      routeKey,
+      buildRunnerRouteStateFromComment(selectedRecord, {
+        last_action: "execution_failed",
+        last_reason: reason,
+        last_conversation_id: String(conversationContext?.id || "").trim(),
+        last_conversation_stage: String(conversationContext?.stage || "").trim(),
+        last_workspace_dir: String(executionPlan.workspaceDir || "").trim(),
+      }),
+    );
+    return {
+      kind: "error",
+      result: {
+        route_key: routeKey,
+        route_name: normalizedRoute.name,
+        outcome: "execution_failed",
+        detail: reason,
+        thread_id: archiveThread.threadID,
+        comment_id: selectedRecord.id,
+        trigger_kind: String(triggerDecision.trigger || "").trim(),
+      },
+    };
+  }
+  const config = loadBotRunnerConfig ? loadBotRunnerConfig() : { roleProfiles: {}, botBindings: {}, routes: [], projectMappings: {} };
+  const stepResults = [];
+  const mergedArtifacts = [];
+  const mergedArtifactPaths = new Set();
+  const mergedBoundaryViolations = [];
+  const totalSteps = plannedSteps.length;
+  for (const [index, rawStep] of plannedSteps.entries()) {
+    const step = safeObject(rawStep);
+    let stepExecutionPlan;
+    try {
+      stepExecutionPlan = resolveRunnerExecutionPlanForRole(
+        normalizedRoute,
+        bot,
+        String(step.role || "").trim(),
+        config,
+        executionDeps,
+      );
+    } catch (err) {
+      const reason = `failed to resolve execution step "${String(step.role || "").trim()}": ${String(err?.message || err)}`;
+      saveRunnerRouteState(
+        routeKey,
+        buildRunnerRouteStateFromComment(selectedRecord, {
+          last_action: "execution_failed",
+          last_reason: reason,
+          last_conversation_id: String(conversationContext?.id || "").trim(),
+          last_conversation_stage: String(conversationContext?.stage || "").trim(),
+          last_workspace_dir: String(executionPlan.workspaceDir || "").trim(),
+        }),
+      );
+      return {
+        kind: "error",
+        result: {
+          route_key: routeKey,
+          route_name: normalizedRoute.name,
+          outcome: "execution_failed",
+          detail: reason,
+          thread_id: archiveThread.threadID,
+          comment_id: selectedRecord.id,
+          trigger_kind: String(triggerDecision.trigger || "").trim(),
+        },
+      };
+    }
+    const stepPayload = buildRoleExecutionStepPayload({
+      aiPayload,
+      step,
+      stepIndex: index + 1,
+      stepTotal: totalSteps,
+      stepExecutionPlan,
+      executedPlan,
+      priorStepResults: stepResults,
+      producedArtifacts: mergedArtifacts,
+    });
+    const stepResult = await runRunnerAIExecution({
+      inputPayload: stepPayload,
+      route: {
+        ...normalizedRoute,
+        role: String(step.role || "").trim(),
+        roleProfile: String(stepExecutionPlan.roleProfileName || step.role || "").trim(),
+      },
+      destination,
+      executionPlan: stepExecutionPlan,
+      deps: executionDeps,
+    });
+    if (stepResult.skip) {
+      const reason = `${String(step.role || "").trim()} step skipped: ${String(stepResult.reason || "execution step returned skip").trim() || "execution step returned skip"}`;
+      saveRunnerRouteState(
+        routeKey,
+        buildRunnerRouteStateFromComment(selectedRecord, {
+          last_action: "execution_failed",
+          last_reason: reason,
+          last_conversation_id: String(conversationContext?.id || "").trim(),
+          last_conversation_stage: String(conversationContext?.stage || "").trim(),
+          last_workspace_dir: String(stepExecutionPlan.workspaceDir || executionPlan.workspaceDir || "").trim(),
+        }),
+      );
+      return {
+        kind: "error",
+        result: {
+          route_key: routeKey,
+          route_name: normalizedRoute.name,
+          outcome: "execution_failed",
+          detail: reason,
+          thread_id: archiveThread.threadID,
+          comment_id: selectedRecord.id,
+          trigger_kind: String(triggerDecision.trigger || "").trim(),
+        },
+      };
+    }
+    const stepValidation = validateWorkspaceArtifacts && String(stepExecutionPlan.workspaceDir || "").trim()
+      ? validateWorkspaceArtifacts(
+        ensureArray(stepResult?.artifacts),
+        stepExecutionPlan.workspaceDir,
+        {
+          permissionMode: String(stepExecutionPlan.roleProfile?.permissionMode || "workspace_write").trim() || "workspace_write",
+        },
+      )
+      : {
+          ok: true,
+          status: "none",
+          artifacts: ensureArray(stepResult?.artifacts),
+          errors: [],
+        };
+    const stepBoundaryViolations = normalizeBoundaryViolations(stepResult?.boundaryViolations);
+    const stepErrors = [
+      ...ensureArray(stepValidation.errors).map((item) => String(item || "").trim()).filter(Boolean),
+      ...stepBoundaryViolations.map((item) => `${item.detail}${item.path ? `: ${item.path}` : ""}`),
+    ];
+    if (requiresArtifactsForExecutionStep(step) && ensureArray(stepValidation.artifacts).length === 0) {
+      stepErrors.push(`${String(step.role || "").trim()} step completed without any validated project artifacts`);
+    }
+    if (stepErrors.length > 0) {
+      const reason = stepErrors.join("; ");
+      saveRunnerRouteState(
+        routeKey,
+        buildRunnerRouteStateFromComment(selectedRecord, {
+          last_action: "execution_failed",
+          last_reason: reason,
+          last_conversation_id: String(conversationContext?.id || "").trim(),
+          last_conversation_stage: String(conversationContext?.stage || "").trim(),
+          last_artifact_validation: String(stepValidation.status || "").trim() || "execution_failed",
+          last_artifact_paths: ensureArray(stepValidation.artifacts).map((item) => String(item.path || item.relativePath || "").trim()).filter(Boolean),
+          last_artifact_errors: stepErrors,
+          last_boundary_violations: stepBoundaryViolations,
+          last_workspace_dir: String(stepExecutionPlan.workspaceDir || executionPlan.workspaceDir || "").trim(),
+        }),
+      );
+      return {
+        kind: "error",
+        result: {
+          route_key: routeKey,
+          route_name: normalizedRoute.name,
+          outcome: "execution_failed",
+          detail: reason,
+          thread_id: archiveThread.threadID,
+          comment_id: selectedRecord.id,
+          trigger_kind: String(triggerDecision.trigger || "").trim(),
+          artifact_validation: String(stepValidation.status || "").trim() || "execution_failed",
+          artifact_paths: ensureArray(stepValidation.artifacts).map((item) => String(item.path || item.relativePath || "").trim()).filter(Boolean),
+          artifact_errors: stepErrors,
+        },
+      };
+    }
+    ensureArray(stepValidation.artifacts).forEach((item) => {
+      const artifact = safeObject(item);
+      const artifactPath = String(artifact.path || artifact.relativePath || "").trim();
+      if (!artifactPath || mergedArtifactPaths.has(artifactPath)) {
+        return;
+      }
+      mergedArtifactPaths.add(artifactPath);
+      mergedArtifacts.push(artifact);
+    });
+    mergedBoundaryViolations.push(...stepBoundaryViolations);
+    stepResults.push({
+      role: String(step.role || "").trim(),
+      goal: String(step.goal || "").trim(),
+      reply: String(stepResult.reply || "").trim(),
+      artifactPaths: ensureArray(stepValidation.artifacts).map((item) => String(safeObject(item).relativePath || safeObject(item).path || "").trim()).filter(Boolean),
+      artifactValidation: String(stepValidation.status || "").trim() || "none",
+    });
+  }
+  const finalStepResult = stepResults[stepResults.length - 1] || {};
+  const summaryRole = String(safeObject(executedPlan).summaryRole || "").trim().toLowerCase();
+  const summaryStepResult = stepResults.findLast
+    ? stepResults.findLast((item) => String(safeObject(item).role || "").trim().toLowerCase() === summaryRole)
+    : [...stepResults].reverse().find((item) => String(safeObject(item).role || "").trim().toLowerCase() === summaryRole);
+  const finalReply = String((summaryStepResult || finalStepResult).reply || "").trim();
+  const summaryBotSelector = normalizeMentionSelector(conversationContext?.summaryBotUsername || conversationContext?.leadBotUsername);
+  const finalContract = conversationContext?.mode === "public_multi_bot" && summaryBotSelector && summaryBotSelector !== currentBotSelector
+    ? {
+        type: "summary_request",
+        actionable: true,
+        assignments: [],
+        summaryBot: summaryBotSelector,
+        nextResponders: [summaryBotSelector],
+      }
+    : {
+        type: summaryRole === "approval" ? "final_summary" : "direct_result",
+        actionable: true,
+        assignments: [],
+        summaryBot: summaryBotSelector,
+        nextResponders: [],
+      };
+  return {
+    kind: "executed",
+    aiResult: {
+      skip: false,
+      reply: finalReply,
+      replyToMessageID: 0,
+      artifacts: mergedArtifacts.map((item) => ({
+        path: String(safeObject(item).path || safeObject(item).relativePath || "").trim(),
+        kind: String(safeObject(item).kind || "").trim(),
+        operation: String(safeObject(item).operation || "").trim(),
+      })),
+      boundaryViolations: mergedBoundaryViolations,
+      contract: finalContract,
+      executionPlanSummary: summarizeExecutedRolePlan(executedPlan, stepResults),
+    },
+    artifactValidation: {
+      ok: true,
+      status: mergedArtifacts.length > 0 ? "validated" : "none",
+      artifacts: mergedArtifacts,
+      errors: [],
+    },
+    executedPlan: summarizeExecutedRolePlan(executedPlan, stepResults),
+  };
+}
 
 function buildConversationPeerMap(bot, normalizedRoute, deps) {
   const peers = typeof deps?.resolveConversationPeerBots === "function"
@@ -1456,22 +1856,60 @@ export async function processRunnerSelectedRecord({
         intervalMs: 4000,
         deps: runtimeDeps,
       });
-  try {
-    await Promise.resolve(typingHeartbeat.ready);
-  } catch {}
-  let aiResult;
-  try {
-    aiResult = await runRunnerAIExecution({
-      inputPayload: aiPayload,
-      route: normalizedRoute,
-      destination,
-      executionPlan,
-      deps: executionDeps,
-    });
-  } finally {
-    await typingHeartbeat.stop();
-  }
-
+  try {
+    await Promise.resolve(typingHeartbeat.ready);
+  } catch {}
+  let aiResult;
+  let dynamicRoleExecution = null;
+  let dynamicExecutionError = null;
+  let artifactValidationOverride = null;
+  let executedRolePlan = null;
+  try {
+    dynamicRoleExecution = await maybeExecuteDynamicRolePlan({
+      aiPayload,
+      routeKey,
+      normalizedRoute,
+      routeState,
+      selectedRecord,
+      pendingOrdered,
+      bot,
+      destination,
+      archiveThread,
+      executionPlan,
+      runtime,
+      executionDeps,
+      triggerDecision,
+      humanIntentContext,
+      conversationContext,
+      saveRunnerRouteState,
+      runRunnerAIExecution,
+      validateWorkspaceArtifacts,
+    });
+    if (dynamicRoleExecution?.kind === "error") {
+      dynamicExecutionError = dynamicRoleExecution.result;
+    } else if (dynamicRoleExecution?.kind === "executed") {
+      aiResult = dynamicRoleExecution.aiResult;
+      artifactValidationOverride = safeObject(dynamicRoleExecution.artifactValidation);
+      executedRolePlan = safeObject(dynamicRoleExecution.executedPlan);
+    } else {
+      aiResult = await runRunnerAIExecution({
+        inputPayload: aiPayload,
+        route: normalizedRoute,
+        destination,
+        executionPlan,
+        deps: executionDeps,
+      });
+    }
+  } finally {
+    await typingHeartbeat.stop();
+  }
+  if (dynamicExecutionError) {
+    return {
+      kind: "error",
+      result: dynamicExecutionError,
+    };
+  }
+
   if (aiResult.skip) {
     if (triggerDecision.requiresDirectReply) {
       const forcedReplyPayload = {
@@ -1524,20 +1962,22 @@ export async function processRunnerSelectedRecord({
     };
   }
 
-  const artifactValidation = validateWorkspaceArtifacts && String(executionPlan.workspaceDir || "").trim()
-    ? validateWorkspaceArtifacts(
-      ensureArray(aiResult?.artifacts),
-      executionPlan.workspaceDir,
-      {
-        permissionMode: String(executionPlan.roleProfile?.permissionMode || "workspace_write").trim() || "workspace_write",
-      },
-    )
-    : {
-        ok: true,
-        status: "none",
-        artifacts: ensureArray(aiResult?.artifacts),
-        errors: [],
-      };
+  const artifactValidation = artifactValidationOverride && Object.keys(artifactValidationOverride).length > 0
+    ? artifactValidationOverride
+    : validateWorkspaceArtifacts && String(executionPlan.workspaceDir || "").trim()
+      ? validateWorkspaceArtifacts(
+        ensureArray(aiResult?.artifacts),
+        executionPlan.workspaceDir,
+        {
+          permissionMode: String(executionPlan.roleProfile?.permissionMode || "workspace_write").trim() || "workspace_write",
+        },
+      )
+      : {
+          ok: true,
+          status: "none",
+          artifacts: ensureArray(aiResult?.artifacts),
+          errors: [],
+        };
   const boundaryViolations = normalizeBoundaryViolations(aiResult?.boundaryViolations);
   const artifactErrors = [
     ...ensureArray(artifactValidation.errors).map((item) => String(item || "").trim()).filter(Boolean),
@@ -1931,6 +2371,7 @@ export async function processRunnerSelectedRecord({
         last_artifact_errors: [],
         last_boundary_violations: [],
         last_workspace_dir: String(executionPlan.workspaceDir || "").trim(),
+        last_execution_plan: executedRolePlan && Object.keys(executedRolePlan).length > 0 ? executedRolePlan : undefined,
       }),
       ...(nextConversationSessions ? { conversation_sessions: nextConversationSessions } : {}),
     },
@@ -1973,9 +2414,10 @@ export async function processRunnerSelectedRecord({
       reply_chars: String(sanitizedReplyText || "").length,
       execution_mode: executionPlan.mode,
       role_profile: executionPlan.roleProfileName,
-      archive_status: deliveryResult.archive?.dry_run
-        ? "dry_run"
-        : deliveryResult.archive?.deduped
+      executed_role_plan: executedRolePlan && Object.keys(executedRolePlan).length > 0 ? executedRolePlan : undefined,
+      archive_status: deliveryResult.archive?.dry_run
+        ? "dry_run"
+        : deliveryResult.archive?.deduped
           ? "deduped"
           : deliveryResult.archive?.ok === false
             ? "archive_error"

package/lib/selftest-runner-scenarios.mjs

@@ -2731,6 +2731,355 @@ export async function runSelftestRunnerScenarios(push, deps) {
     push("single_bot_human_request_guardrail_audit_upgrades_to_actionable", false, String(err?.message || err));
   }
 
+  try {
+    let deliveryCalls = 0;
+    let aiCalls = 0;
+    const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), "metheus-runner-selftest-multi-step-success-"));
+    const processed = await processRunnerSelectedRecord({
+      routeKey: "single-bot-multi-step-execution-success-key",
+      normalizedRoute: normalizeRunnerRoute({
+        name: "telegram-monitor-single-bot-multi-step-success",
+        project_id: selftestProjectID,
+        provider: "telegram",
+        role: "monitor",
+        role_profile: "monitor",
+        destination_id: "dest-1",
+        destination_label: "Main Room",
+        server_bot_name: "RyoAI_bot",
+        server_bot_id: "bot-lead-1",
+        trigger_policy: {
+          mentions_only: true,
+          direct_messages: true,
+          reply_to_bot_messages: true,
+        },
+        archive_policy: {
+          mirror_replies: true,
+          dedupe_inbound: true,
+          dedupe_outbound: true,
+          skip_bot_messages: true,
+        },
+        dry_run_delivery: true,
+      }),
+      selectedRecord: {
+        id: "comment-single-bot-multi-step-execution-success",
+        createdAt: "2026-03-17T01:00:00.000Z",
+        parsedArchive: {
+          kind: "telegram_message",
+          chatID: "-100123",
+          chatType: "supergroup",
+          senderIsBot: false,
+          body: "@RyoAI_bot create the project README now.",
+          mentionUsernames: ["RyoAI_bot"],
+          messageID: 1301,
+        },
+      },
+      pendingOrdered: [],
+      bot: {
+        id: "bot-lead-1",
+        name: "RyoAI_bot",
+        username: "RyoAI_bot",
+        role: "monitor",
+        provider: "telegram",
+      },
+      destination: {
+        id: "dest-1",
+        label: "Main Room",
+        provider: "telegram",
+        chatID: "-100123",
+      },
+      archiveThread: {
+        threadID: "thread-1",
+        workItemID: "work-item-1",
+      },
+      executionPlan: {
+        mode: "role_profile",
+        roleProfileName: "monitor",
+        roleProfile: {
+          client: "sample",
+          model: "",
+          permissionMode: "read_only",
+          reasoningEffort: "low",
+        },
+        workspaceDir,
+        workspaceSource: "selftest",
+        usedCommandFallback: false,
+      },
+      runtime: {
+        baseURL: "https://example.test",
+        token: "selftest-token",
+        timeoutSeconds: 30,
+        actor: { user_id: "user-1" },
+      },
+      deps: {
+        saveRunnerRouteState: () => {},
+        startRunnerTypingHeartbeat: () => ({ async stop() {} }),
+        runRunnerAIExecution: async ({ inputPayload }) => {
+          aiCalls += 1;
+          if (String(inputPayload?.task || "").trim() !== "execute_project_role_step") {
+            throw new Error(`unexpected task ${String(inputPayload?.task || "(none)")}`);
+          }
+          const stepRole = String(inputPayload?.execution_step?.role || "").trim();
+          if (stepRole === "monitor") {
+            return {
+              skip: false,
+              reply: "Inspected the project requirements and confirmed the target README scope.",
+            };
+          }
+          if (stepRole === "worker") {
+            const readmePath = path.join(workspaceDir, "README.md");
+            fs.writeFileSync(readmePath, "# README\n", "utf8");
+            return {
+              skip: false,
+              reply: "Created the README document.",
+              artifacts: [{ path: "README.md", kind: "document", operation: "create" }],
+            };
+          }
+          if (stepRole === "review") {
+            return {
+              skip: false,
+              reply: "Reviewed the README and confirmed it is ready to share.",
+            };
+          }
+          throw new Error(`unexpected step role ${stepRole}`);
+        },
+        performLocalBotDelivery: async () => {
+          deliveryCalls += 1;
+          return {
+            delivery: { dryRun: true, body: {} },
+            archive: {},
+          };
+        },
+        serializeRunnerTriggerPolicy: (value) => value,
+        serializeRunnerArchivePolicy: (value) => value,
+        buildRunnerExecutionDeps: () => ({
+          validateWorkspaceArtifacts,
+          analyzeHumanConversationIntentWithAI: async () => ({
+            mode: "single_bot",
+            lead_bot: "ryoai_bot",
+            participants: ["ryoai_bot"],
+            initial_responders: ["ryoai_bot"],
+            allowed_responders: ["ryoai_bot"],
+            summary_bot: "",
+            allow_bot_to_bot: false,
+            reply_expectation: "actionable",
+          }),
+          planRoleExecutionWithAI: async () => ({
+            requiresExecution: true,
+            summaryRole: "review",
+            steps: [
+              { role: "monitor", goal: "Inspect project requirements" },
+              { role: "worker", goal: "Create README", artifactsRequired: true },
+              { role: "review", goal: "Review generated README" },
+            ],
+          }),
+          resolveRunnerExecutionPlanForRole: (_route, _bot, roleName) => ({
+            mode: "role_profile",
+            roleProfileName: String(roleName || "").trim(),
+            roleProfile: {
+              client: "sample",
+              model: "",
+              permissionMode: String(roleName || "").trim() === "worker" ? "workspace_write" : "read_only",
+              reasoningEffort: String(roleName || "").trim() === "worker" ? "medium" : "low",
+            },
+            workspaceDir,
+            workspaceSource: "selftest",
+            usedCommandFallback: false,
+          }),
+          loadBotRunnerConfig: () => ({
+            roleProfiles: {},
+            botBindings: {},
+            routes: [],
+            projectMappings: {},
+          }),
+        }),
+        buildRunnerDeliveryDeps: () => ({}),
+        buildRunnerRuntimeDeps: () => ({}),
+        resolveConversationPeerBots: () => [
+          { id: "bot-lead-1", name: "RyoAI_bot" },
+        ],
+      },
+    });
+    push(
+      "single_bot_human_execution_request_runs_multi_role_plan",
+      processed.kind === "replied"
+        && aiCalls === 3
+        && deliveryCalls === 1
+        && ensureArray(processed.result?.artifact_paths).includes("README.md")
+        && ensureArray(processed.result?.executed_role_plan?.steps).length === 3,
+      `kind=${String(processed.kind || "(none)")} ai_calls=${aiCalls} delivery_calls=${deliveryCalls} artifacts=${ensureArray(processed.result?.artifact_paths).join(",")} steps=${ensureArray(processed.result?.executed_role_plan?.steps).length}`,
+    );
+  } catch (err) {
+    push("single_bot_human_execution_request_runs_multi_role_plan", false, String(err?.message || err));
+  }
+
+  try {
+    let deliveryCalls = 0;
+    let aiCalls = 0;
+    const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), "metheus-runner-selftest-multi-step-worker-fail-"));
+    const processed = await processRunnerSelectedRecord({
+      routeKey: "single-bot-multi-step-worker-artifact-required-key",
+      normalizedRoute: normalizeRunnerRoute({
+        name: "telegram-monitor-single-bot-multi-step-worker-fail",
+        project_id: selftestProjectID,
+        provider: "telegram",
+        role: "monitor",
+        role_profile: "monitor",
+        destination_id: "dest-1",
+        destination_label: "Main Room",
+        server_bot_name: "RyoAI_bot",
+        server_bot_id: "bot-lead-1",
+        trigger_policy: {
+          mentions_only: true,
+          direct_messages: true,
+          reply_to_bot_messages: true,
+        },
+        archive_policy: {
+          mirror_replies: true,
+          dedupe_inbound: true,
+          dedupe_outbound: true,
+          skip_bot_messages: true,
+        },
+        dry_run_delivery: true,
+      }),
+      selectedRecord: {
+        id: "comment-single-bot-multi-step-worker-artifact-required",
+        createdAt: "2026-03-17T01:00:01.000Z",
+        parsedArchive: {
+          kind: "telegram_message",
+          chatID: "-100123",
+          chatType: "supergroup",
+          senderIsBot: false,
+          body: "@RyoAI_bot write the README file now.",
+          mentionUsernames: ["RyoAI_bot"],
+          messageID: 1302,
+        },
+      },
+      pendingOrdered: [],
+      bot: {
+        id: "bot-lead-1",
+        name: "RyoAI_bot",
+        username: "RyoAI_bot",
+        role: "monitor",
+        provider: "telegram",
+      },
+      destination: {
+        id: "dest-1",
+        label: "Main Room",
+        provider: "telegram",
+        chatID: "-100123",
+      },
+      archiveThread: {
+        threadID: "thread-1",
+        workItemID: "work-item-1",
+      },
+      executionPlan: {
+        mode: "role_profile",
+        roleProfileName: "monitor",
+        roleProfile: {
+          client: "sample",
+          model: "",
+          permissionMode: "read_only",
+          reasoningEffort: "low",
+        },
+        workspaceDir,
+        workspaceSource: "selftest",
+        usedCommandFallback: false,
+      },
+      runtime: {
+        baseURL: "https://example.test",
+        token: "selftest-token",
+        timeoutSeconds: 30,
+        actor: { user_id: "user-1" },
+      },
+      deps: {
+        saveRunnerRouteState: () => {},
+        startRunnerTypingHeartbeat: () => ({ async stop() {} }),
+        runRunnerAIExecution: async ({ inputPayload }) => {
+          aiCalls += 1;
+          const stepRole = String(inputPayload?.execution_step?.role || "").trim();
+          if (stepRole === "monitor") {
+            return {
+              skip: false,
+              reply: "Inspected the request.",
+            };
+          }
+          if (stepRole === "worker") {
+            return {
+              skip: false,
+              reply: "Started the README work.",
+              artifacts: [],
+            };
+          }
+          throw new Error(`unexpected step role ${stepRole}`);
+        },
+        performLocalBotDelivery: async () => {
+          deliveryCalls += 1;
+          return {
+            delivery: { dryRun: true, body: {} },
+            archive: {},
+          };
+        },
+        serializeRunnerTriggerPolicy: (value) => value,
+        serializeRunnerArchivePolicy: (value) => value,
+        buildRunnerExecutionDeps: () => ({
+          validateWorkspaceArtifacts,
+          analyzeHumanConversationIntentWithAI: async () => ({
+            mode: "single_bot",
+            lead_bot: "ryoai_bot",
+            participants: ["ryoai_bot"],
+            initial_responders: ["ryoai_bot"],
+            allowed_responders: ["ryoai_bot"],
+            summary_bot: "",
+            allow_bot_to_bot: false,
+            reply_expectation: "actionable",
+          }),
+          planRoleExecutionWithAI: async () => ({
+            requiresExecution: true,
+            summaryRole: "monitor",
+            steps: [
+              { role: "monitor", goal: "Inspect request" },
+              { role: "worker", goal: "Write README", artifactsRequired: true },
+            ],
+          }),
+          resolveRunnerExecutionPlanForRole: (_route, _bot, roleName) => ({
+            mode: "role_profile",
+            roleProfileName: String(roleName || "").trim(),
+            roleProfile: {
+              client: "sample",
+              model: "",
+              permissionMode: String(roleName || "").trim() === "worker" ? "workspace_write" : "read_only",
+              reasoningEffort: "low",
+            },
+            workspaceDir,
+            workspaceSource: "selftest",
+            usedCommandFallback: false,
+          }),
+          loadBotRunnerConfig: () => ({
+            roleProfiles: {},
+            botBindings: {},
+            routes: [],
+            projectMappings: {},
+          }),
+        }),
+        buildRunnerDeliveryDeps: () => ({}),
+        buildRunnerRuntimeDeps: () => ({}),
+        resolveConversationPeerBots: () => [
+          { id: "bot-lead-1", name: "RyoAI_bot" },
+        ],
+      },
+    });
+    push(
+      "single_bot_worker_step_requires_artifacts_in_multi_role_plan",
+      processed.kind === "error"
+        && String(processed.result?.outcome || "") === "execution_failed"
+        && deliveryCalls === 0
+        && /validated project artifacts/i.test(String(processed.result?.detail || "")),
+      `kind=${String(processed.kind || "(none)")} outcome=${String(processed.result?.outcome || "(none)")} ai_calls=${aiCalls} delivery_calls=${deliveryCalls} detail=${String(processed.result?.detail || "(none)")}`,
+    );
+  } catch (err) {
+    push("single_bot_worker_step_requires_artifacts_in_multi_role_plan", false, String(err?.message || err));
+  }
+
   try {
     let aiCalls = 0;
     const processed = await processRunnerSelectedRecord({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metheus-governance-mcp-cli",
-  "version": "0.2.146",
+  "version": "0.2.147",
   "description": "Metheus Governance MCP CLI (setup + stdio proxy)",
   "type": "module",
   "files": [