metheus-governance-mcp-cli 0.2.214 → 0.2.216

package/cli.mjs

@@ -2364,6 +2364,11 @@ function normalizeBotRunnerRequests(rawRequests, nowMs = Date.now()) {
       ),
       ai_reply_generated_at: firstNonEmptyString([entry.ai_reply_generated_at, entry.aiReplyGeneratedAt]),
       ai_reply_preview: String(entry.ai_reply_preview || entry.aiReplyPreview || "").trim(),
+      response_contract_validation_status: String(entry.response_contract_validation_status || entry.responseContractValidationStatus || "").trim().toLowerCase(),
+      response_contract_validation_reason: String(entry.response_contract_validation_reason || entry.responseContractValidationReason || "").trim(),
+      response_contract_validation_targets: ensureArray(entry.response_contract_validation_targets || entry.responseContractValidationTargets)
+        .map((value) => normalizeTelegramMentionUsername(value))
+        .filter(Boolean),
       delivery_status: String(entry.delivery_status || entry.deliveryStatus || "").trim().toLowerCase(),
       archive_status: String(entry.archive_status || entry.archiveStatus || "").trim().toLowerCase(),
       transport_error: String(entry.transport_error || entry.transportError || "").trim(),
@@ -3658,28 +3663,13 @@ function runnerRequestRequiresActionableContract(requestRaw) {
   const replyExpectation = String(request.conversation_reply_expectation || "").trim().toLowerCase();
   const executionContractType = String(request.execution_contract_type || "").trim().toLowerCase();
   const intentMode = String(request.conversation_intent_mode || "").trim().toLowerCase();
-  const intentType = String(
-    request.conversation_intent_type
-    || request.intent_type
-    || request.normalized_intent
-    || "",
-  ).trim().toLowerCase();
-  const hasExecutionIntent = [
-    "general_execution",
-    "ctxpack_mutation",
-    "workitem_mutation",
-  ].includes(intentType);
   if (request.execution_contract_actionable === true) {
     return true;
   }
   if (["delegation", "direct_result", "summary_request", "final_summary"].includes(executionContractType)) {
     return true;
   }
-  if (
-    intentMode === "single_bot"
-    && replyExpectation === "actionable"
-    && hasExecutionIntent
-  ) {
+  if (intentMode === "single_bot" && replyExpectation === "actionable") {
     return true;
   }
   return false;
@@ -4495,6 +4485,9 @@ function markRunnerRequestLifecycle({
   aiReplyGenerated = false,
   aiReplyGeneratedAt = "",
   aiReplyPreview = "",
+  responseContractValidationStatus = "",
+  responseContractValidationReason = "",
+  responseContractValidationTargets = [],
   deliveryStatus = "",
   archiveStatus = "",
   transportError = "",
@@ -4610,6 +4603,18 @@ function markRunnerRequestLifecycle({
       ? firstNonEmptyString([aiReplyGeneratedAt, existing.ai_reply_generated_at, nowISO])
       : String(existing.ai_reply_generated_at || "").trim(),
     ai_reply_preview: String(aiReplyPreview || existing.ai_reply_preview || "").trim(),
+    response_contract_validation_status: String(
+      responseContractValidationStatus || existing.response_contract_validation_status || "",
+    ).trim().toLowerCase(),
+    response_contract_validation_reason: String(
+      responseContractValidationReason || existing.response_contract_validation_reason || "",
+    ).trim(),
+    response_contract_validation_targets: uniqueOrderedStrings(
+      ensureArray(responseContractValidationTargets).length
+        ? responseContractValidationTargets
+        : existing.response_contract_validation_targets,
+      normalizeTelegramMentionUsername,
+    ),
     delivery_status: String(deliveryStatus || existing.delivery_status || "").trim().toLowerCase(),
     archive_status: String(archiveStatus || existing.archive_status || "").trim().toLowerCase(),
     transport_error: String(transportError || existing.transport_error || "").trim(),
@@ -8789,6 +8794,9 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
           aiReplyGenerated: processed.result?.ai_reply_generated === true,
           aiReplyGeneratedAt: String(processed.result?.ai_reply_generated_at || "").trim(),
           aiReplyPreview: String(processed.result?.ai_reply_preview || "").trim(),
+          responseContractValidationStatus: String(processed.result?.response_contract_validation_status || "").trim(),
+          responseContractValidationReason: String(processed.result?.response_contract_validation_reason || "").trim(),
+          responseContractValidationTargets: ensureArray(processed.result?.response_contract_validation_targets),
           deliveryStatus: String(processed.result?.delivery_status || "").trim(),
           archiveStatus: String(processed.result?.archive_status || "").trim(),
           transportError: String(processed.result?.transport_error || "").trim(),
@@ -11204,6 +11212,9 @@ async function runRunnerStartResolvedRoutes(routes, flags, options = {}) {
                         aiReplyGenerated: processed.result?.ai_reply_generated === true,
                         aiReplyGeneratedAt: String(processed.result?.ai_reply_generated_at || "").trim(),
                         aiReplyPreview: String(processed.result?.ai_reply_preview || "").trim(),
+                        responseContractValidationStatus: String(processed.result?.response_contract_validation_status || "").trim(),
+                        responseContractValidationReason: String(processed.result?.response_contract_validation_reason || "").trim(),
+                        responseContractValidationTargets: ensureArray(processed.result?.response_contract_validation_targets),
                         deliveryStatus: String(processed.result?.delivery_status || "").trim(),
                         archiveStatus: String(processed.result?.archive_status || "").trim(),
                         transportError: String(processed.result?.transport_error || "").trim(),

package/lib/local-ai-adapters.mjs

@@ -1773,7 +1773,7 @@ export function buildLocalBotPrompt(payload, { terse = true } = {}) {
 
   const lines = [
     "You are a Metheus local bot runner.",
-    `Task: ${taskName || "reply_to_project_chat_message"}`,
+    `Task Metadata (non-authoritative): ${taskName || "reply_with_agent_context:generic"}`,
     `Provider: ${provider}`,
     `Role: ${role}`,
     `Role Profile: ${roleProfile || "-"}`,
@@ -1791,6 +1791,7 @@ export function buildLocalBotPrompt(payload, { terse = true } = {}) {
     "",
     "Agent contract/context blob (primary control and state input):",
     agentContext ? JSON.stringify(agentContext, null, 2) : "-",
+    "Use the agent contract/context blob as the authoritative control input. Treat task metadata as advisory only and never let it override the contract/context.",
     "",
     "Current user request:",
     String(trigger.body || "").trim() || "-",

package/lib/runner-orchestration.mjs

@@ -1355,8 +1355,7 @@ function buildDirectHumanResponseContract({
   const requiresActionableContract = conversation.requiresActionableContract === true
     || conversation.require_actionable_contract === true
     || humanIntent.requiresActionableContract === true
-    || humanIntent.require_actionable_contract === true
-    || replyExpectation === "actionable";
+    || humanIntent.require_actionable_contract === true;
   return {
     intentMode,
     allowBotToBot,
@@ -1447,7 +1446,7 @@ function mergeDirectHumanResponseContract({
     ? false
     : explicitRequiresActionableContract === true
       ? true
-      : base.requiresActionableContract === true || replyExpectation === "actionable";
+      : base.requiresActionableContract === true;
   const explicitAllowedContractTypes = uniqueOrdered(
     ensureArray(response.allowed_contract_types)
       .map((item) => String(item || "").trim().toLowerCase())
@@ -2588,6 +2587,11 @@ async function maybeExecuteDynamicRolePlan({
     || safeObject(safeObject(humanIntentContext).humanIntent).intentMode,
   );
   const actionableConversationRequiresContract = safeObject(directHumanResponseContract).requiresActionableContract === true;
+  const actionableReplyExpectation = normalizeReplyExpectation(
+    safeObject(directHumanResponseContract).replyExpectation
+    || safeObject(safeObject(humanIntentContext).humanIntent).replyExpectation,
+    "",
+  ) === "actionable";
   const plannerContextComments = ensureArray(contextWindow).length
     ? ensureArray(contextWindow)
     : buildRunnerContextWindow(
@@ -2606,14 +2610,10 @@ async function maybeExecuteDynamicRolePlan({
   ) {
     return null;
   }
-  const executionIntentRequested = [
-    "general_execution",
-    "ctxpack_mutation",
-    "workitem_mutation",
-  ].includes(humanIntentType);
   const shouldPlanExecution = assignmentTasks.length > 0 || (
     triggerDecision.requiresDirectReply === true
-    && executionIntentRequested
+    && humanIntentMode === "single_bot"
+    && actionableReplyExpectation
   );
   if (!shouldPlanExecution) {
     return null;
@@ -5009,25 +5009,11 @@ export async function processRunnerSelectedRecord({
   const directHumanPeerMap = humanIntentContext?.peerMap instanceof Map
     ? humanIntentContext.peerMap
     : buildConversationPeerMap(bot, normalizedRoute, executionDeps);
-  const delegatedBotMentions = extractManagedPeerMentionSelectors(
-    String(aiResult.reply || "").trim(),
-    directHumanPeerMap,
-    currentBotSelector,
-  );
   const requiredDelegationTargets = uniqueOrdered(
-    (
-      delegatedBotMentions.length > 0
-        ? delegatedBotMentions
-        : requiresPeerDelegationContract
-          ? peerAllowedResponders
-          : []
-    )
+    (requiresPeerDelegationContract ? peerAllowedResponders : [])
       .map((item) => normalizeMentionSelector(item))
       .filter(Boolean),
   );
-  if (delegatedBotMentions.length > 0) {
-    allowedActionableTypes = new Set(["delegation"]);
-  }
   if (requiresPeerDelegationContract) {
     allowedActionableTypes = new Set(["delegation"]);
     requiresActionableContract = true;
@@ -5037,97 +5023,24 @@ export async function processRunnerSelectedRecord({
     && executionContract.actionable === true
     && (!allowedActionableTypes.size || allowedActionableTypes.has(String(executionContract.type || "").trim().toLowerCase())),
   );
-  if (!requiresActionableContract && requiredDelegationTargets.length > 0) {
-    requiresActionableContract = true;
-  }
-  if (
-    !requiresActionableContract
-    && !hasValidActionableContract
-    && effectiveTriggerDecision.requiresDirectReply === true
-    && !conversationContext
-    && !safeObject(selectedRecord?.parsedArchive).senderIsBot
-    && typeof executionDeps?.auditDirectHumanReplyWithAI === "function"
-  ) {
-    const auditPeerMap = humanIntentContext?.peerMap instanceof Map
-      ? humanIntentContext.peerMap
-      : buildConversationPeerMap(bot, normalizedRoute, executionDeps);
-    try {
-      const audit = await executionDeps.auditDirectHumanReplyWithAI({
-        humanMessageText: String(safeObject(selectedRecord?.parsedArchive).body || "").trim(),
-        botReplyText: String(aiResult.reply || "").trim(),
-        currentBotUsername: String(bot?.username || bot?.name || "").trim(),
-        managedBots: buildConversationParticipantViews(Array.from(auditPeerMap.keys()), auditPeerMap),
-        workspaceDir: String(effectiveExecutionPlan.workspaceDir || process.cwd()).trim() || process.cwd(),
-      });
-      if (audit?.requires_actionable_contract === true && audit?.reply_satisfies_request !== true) {
-        requiresActionableContract = true;
-      }
-    } catch {}
-  }
-  if (requiresActionableContract && !hasValidActionableContract) {
-    const forcedContractPayload = {
-      ...aiPayload,
-      response_contract: {
-        ...effectiveResponseContractPayload,
-        allow_skip: false,
-        must_reply: true,
-        require_actionable_contract: true,
-        human_intent_mode: String(effectiveResponseContractPayload.human_intent_mode || "").trim(),
-        human_lead_bot: String(effectiveResponseContractPayload.human_lead_bot || "").trim(),
-        human_summary_bot: String(effectiveResponseContractPayload.human_summary_bot || "").trim(),
-        human_allowed_responders: ensureArray(effectiveResponseContractPayload.human_allowed_responders).length
-          ? ensureArray(effectiveResponseContractPayload.human_allowed_responders)
-          : uniqueOrdered([
-            currentBotSelector,
-            ...requiredDelegationTargets,
-          ].filter(Boolean)),
-        allow_bot_to_bot: requiredDelegationTargets.length > 0
-          || requiresPeerDelegationContract
-          || effectiveResponseContractPayload.human_intent_mode === "delegated_single_lead",
-        allowed_contract_types: requiredDelegationTargets.length > 0 || requiresPeerDelegationContract
-          ? ["delegation"]
-          : ensureArray(effectiveResponseContractPayload.allowed_contract_types).length
-            ? ensureArray(effectiveResponseContractPayload.allowed_contract_types)
-            : ["direct_result", "summary_request", "final_summary"],
-        required_delegation_targets: requiredDelegationTargets,
-        contract_hint: requiredDelegationTargets.length > 0
-          ? `Your previous reply mentioned ${requiredDelegationTargets.map((item) => `@${String(item || "").trim().replace(/^@+/, "")}`).join(", ")} without a delegation contract. Return contract.type=\"delegation\" with actionable=true, assignments for those exact bots, and matching next_responders.`
-          : "",
-      },
+  const responseContractValidation = (() => {
+    if (requiresActionableContract && !hasValidActionableContract) {
+      return {
+        ok: false,
+        status: "missing_required_contract",
+        reason: requiredDelegationTargets.length > 0
+          ? `reply mentioned managed peer bot(s) ${requiredDelegationTargets.map((item) => `@${String(item || "").trim().replace(/^@+/, "")}`).join(", ")} without a matching delegation contract`
+          : "reply did not produce a required execution contract",
+        targets: requiredDelegationTargets,
+      };
+    }
+    return {
+      ok: true,
+      status: "valid",
+      reason: "",
+      targets: requiredDelegationTargets,
     };
-    effectiveResponseContractPayload = safeObject(forcedContractPayload.response_contract);
-    allowedActionableTypes = new Set(
-      ensureArray(effectiveResponseContractPayload.allowed_contract_types)
-        .map((item) => String(item || "").trim().toLowerCase())
-        .filter(Boolean),
-    );
-    aiResult = await runRunnerAIExecution({
-      inputPayload: forcedContractPayload,
-      route: normalizedRoute,
-      destination,
-      executionPlan: effectiveExecutionPlan,
-      deps: executionDeps,
-    });
-    executionContract = conversationContext?.mode === "public_multi_bot"
-      ? normalizeConversationExecutionContract(
-        aiResult.contract,
-        {
-          allowedResponderSelectors: conversationContext.allowedResponderSelectors,
-          summaryBotUsername: conversationContext.summaryBotUsername,
-        },
-        { currentBotSelector, excludeCurrentTargetAssignments: true },
-      )
-      : normalizeResponseExecutionContract(
-        aiResult.contract,
-        effectiveResponseContractPayload,
-        { currentBotSelector },
-      );
-    hasValidActionableContract = Boolean(
-      executionContract
-      && executionContract.actionable === true
-      && (!allowedActionableTypes.size || allowedActionableTypes.has(String(executionContract.type || "").trim().toLowerCase())),
-    );
-  }
+  })();
   directHumanResponseContract = mergeDirectHumanResponseContract({
     baseContract: directHumanResponseContract,
     responseContract: effectiveResponseContractPayload,
@@ -5153,56 +5066,6 @@ export async function processRunnerSelectedRecord({
       directHumanResponseContract,
       executionContract,
     });
-  if (requiresActionableContract) {
-    const validContract = hasValidActionableContract;
-    if (!validContract) {
-      const reason = requiredDelegationTargets.length > 0
-        ? `reply mentioned managed peer bot(s) ${requiredDelegationTargets.map((item) => `@${String(item || "").trim().replace(/^@+/, "")}`).join(", ")} without a required delegation contract`
-        : "reply did not produce an actionable execution contract";
-        const directHumanExecutionFailure = effectiveTriggerDecision.requiresDirectReply === true
-        && !conversationContext
-        && !safeObject(selectedRecord?.parsedArchive).senderIsBot;
-      saveRunnerRouteState(
-        routeKey,
-        buildRunnerRouteStateFromComment(selectedRecord, {
-          last_action: directHumanExecutionFailure
-            ? "execution_failed"
-            : conversationContext?.mode === "public_multi_bot"
-              ? "conversation_skipped"
-              : "policy_violation",
-          last_reason: reason,
-          last_conversation_id: String(conversationContext?.id || "").trim(),
-          last_conversation_stage: String(conversationContext?.stage || "").trim(),
-          last_workspace_dir: String(effectiveExecutionPlan.workspaceDir || "").trim(),
-          ...intentStatePatch,
-        }),
-      );
-      if (directHumanExecutionFailure) {
-        const failureDelivery = await maybeDeliverFailureReply(reason);
-        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(effectiveTriggerDecision.trigger || "").trim(),
-            failure_reply_sent: Boolean(failureDelivery),
-          },
-        };
-      }
-      return {
-        kind: "skipped",
-        skippedRecord: {
-          id: selectedRecord.id,
-          reason,
-          messageID: intFromRawAllowZero(selectedRecord?.parsedArchive?.messageID, 0),
-        },
-      };
-    }
-  }
   const normalizedExecutionContractType = String(executionContract?.type || "").trim().toLowerCase();
   const effectiveResolvedIntentType = normalizeHumanIntentType(
     directHumanResponseContract.intentType || resolvedIntentType,
@@ -5333,17 +5196,7 @@ export async function processRunnerSelectedRecord({
       },
     };
   }
-  if (
-    conversationContext?.mode === "public_multi_bot"
-    && String(conversationContext.intentMode || "").trim() === "delegated_single_lead"
-    && currentBotSelector
-    && currentBotSelector !== normalizeMentionSelector(conversationContext.leadBotUsername)
-    && (!executionContract || executionContract.actionable !== true)
-  ) {
-    executionContract = buildImplicitSummaryRequestContract(conversationContext, currentBotSelector);
-  }
-
-  const replyToMessageID = aiResult.replyToMessageID > 0
+  const replyToMessageID = aiResult.replyToMessageID > 0
     ? aiResult.replyToMessageID
     : intFromRawAllowZero(selectedRecord.parsedArchive?.messageID, 0);
   const sanitizedReplyText = sanitizeForcedDirectReplyText({
@@ -5469,6 +5322,9 @@ export async function processRunnerSelectedRecord({
         last_trigger: String(effectiveTriggerDecision.trigger || "").trim(),
         last_conversation_id: String(effectiveConversationContext?.id || "").trim(),
         last_conversation_stage: String(effectiveConversationContext?.stage || "").trim(),
+        last_contract_validation_status: String(responseContractValidation.status || "").trim(),
+        last_contract_validation_reason: String(responseContractValidation.reason || "").trim(),
+        last_contract_validation_targets: ensureArray(responseContractValidation.targets),
         last_speaker_bot_username: normalizeMentionSelector(bot?.username || bot?.name),
         last_workspace_dir: String(effectiveExecutionPlan.workspaceDir || "").trim(),
         ...intentStatePatch,
@@ -5507,6 +5363,9 @@ export async function processRunnerSelectedRecord({
         archive_status: "not_attempted",
         transport_error: transportError,
         archive_error: "",
+        response_contract_validation_status: String(responseContractValidation.status || "").trim(),
+        response_contract_validation_reason: String(responseContractValidation.reason || "").trim(),
+        response_contract_validation_targets: ensureArray(responseContractValidation.targets),
         reply_chars: String(sanitizedReplyText || "").length,
         execution_mode: effectiveExecutionPlan.mode,
         role_profile: effectiveExecutionPlan.roleProfileName,
@@ -5593,7 +5452,10 @@ export async function processRunnerSelectedRecord({
         last_reply_message_id: intFromRawAllowZero(
           safeObject(deliveryResult.delivery.body).result?.message_id ?? safeObject(deliveryResult.delivery.body).message_id,
           0,
-        ),
+        ),
+        last_contract_validation_status: String(responseContractValidation.status || "").trim(),
+        last_contract_validation_reason: String(responseContractValidation.reason || "").trim(),
+        last_contract_validation_targets: ensureArray(responseContractValidation.targets),
         last_trigger: String(effectiveTriggerDecision.trigger || "").trim(),
         last_reason: effectiveConversationContext?.mode === "public_multi_bot"
           ? [
@@ -5691,6 +5553,9 @@ export async function processRunnerSelectedRecord({
       ai_reply_generated: true,
       ai_reply_generated_at: aiReplyGeneratedAt,
       ai_reply_preview: aiReplyPreview,
+      response_contract_validation_status: String(responseContractValidation.status || "").trim(),
+      response_contract_validation_reason: String(responseContractValidation.reason || "").trim(),
+      response_contract_validation_targets: ensureArray(responseContractValidation.targets),
       delivery_status: deliveryResult.delivery.dryRun ? "dry_run" : "delivered",
       execution_mode: effectiveExecutionPlan.mode,
       role_profile: effectiveExecutionPlan.roleProfileName,

package/lib/runner-trigger.mjs

@@ -95,15 +95,8 @@ function buildRunnerTaskName(humanIntentType, humanIntentContract = null) {
   const normalizedIntentType = String(humanIntentType || "").trim().toLowerCase();
   const contract = safeObject(humanIntentContract);
   const executionContractType = String(contract.executionContractType || contract.execution_contract_type || "").trim().toLowerCase();
-  if (normalizedIntentType === "status_query") return "answer_project_status_query";
-  if (normalizedIntentType === "workspace_query") return "answer_project_workspace_query";
-  if (normalizedIntentType === "bot_role_query") return "answer_project_bot_role_query";
-  if (normalizedIntentType === "artifact_location_query") return "answer_project_artifact_location_query";
-  if (normalizedIntentType === "small_talk") return "reply_to_project_chat_greeting";
-  if (executionContractType) {
-    return "reply_to_project_actionable_message";
-  }
-  return "reply_to_project_chat_message";
+  const legacyHint = executionContractType || normalizedIntentType || "generic";
+  return `reply_with_agent_context:${legacyHint}`;
 }
 
 export function evaluateTelegramRunnerTrigger(record, route, bot) {
@@ -184,8 +177,14 @@ export function buildRunnerInputPayload({
   const executionContractType = String(
     directHumanIntent.executionContractType || directHumanIntent.execution_contract_type || "",
   ).trim().toLowerCase();
+  const taskMetadata = buildRunnerTaskName(directHumanIntent.intentType, directHumanIntent);
   return {
-    task: buildRunnerTaskName(directHumanIntent.intentType, directHumanIntent),
+    task: taskMetadata,
+    task_metadata: {
+      legacy_task_hint: taskMetadata,
+      intent_type: String(directHumanIntent.intentType || "").trim(),
+      execution_contract_type: executionContractType,
+    },
     project_id: String(route?.projectID || "").trim(),
     provider: String(route?.provider || "").trim(),
     role: String(bot?.role || route?.role || "").trim(),

package/lib/selftest-runner-scenarios.mjs

@@ -4565,18 +4565,20 @@ export async function runSelftestRunnerScenarios(push, deps) {
       },
     });
     push(
-      "direct_human_public_delegate_reply_is_upgraded_to_actionable_contract",
+      "direct_human_public_delegate_reply_records_missing_contract_without_fabrication",
       processed.kind === "replied"
-        && aiCalls >= 1
+        && aiCalls === 1
         && String(deliveredConversation[0]?.mode || "") === "public_multi_bot"
         && String(deliveredConversation[0]?.leadBotUsername || "") === "ryoai_bot"
         && Array.isArray(deliveredConversation[0]?.allowedResponderSelectors)
         && deliveredConversation[0].allowedResponderSelectors.includes("ryoai3_bot")
-        && String(deliveredConversation[0]?.executionContract?.type || "") === "delegation",
-      `kind=${String(processed.kind || "(none)")} ai_calls=${aiCalls} mode=${String(deliveredConversation[0]?.mode || "(none)")} contract=${String(deliveredConversation[0]?.executionContract?.type || "(none)")} required_targets=${JSON.stringify(safeObject(forcedContractPayload?.response_contract).required_delegation_targets || [])}`,
+        && !String(deliveredConversation[0]?.executionContract?.type || "").trim()
+        && String(processed.result?.response_contract_validation_status || "") === "missing_required_contract"
+        && ensureArray(processed.result?.response_contract_validation_targets).includes("ryoai3_bot"),
+      `kind=${String(processed.kind || "(none)")} ai_calls=${aiCalls} mode=${String(deliveredConversation[0]?.mode || "(none)")} contract=${String(deliveredConversation[0]?.executionContract?.type || "(none)")} validation=${String(processed.result?.response_contract_validation_status || "(none)")} targets=${JSON.stringify(processed.result?.response_contract_validation_targets || [])}`,
     );
   } catch (err) {
-    push("direct_human_public_delegate_reply_is_upgraded_to_actionable_contract", false, String(err?.message || err));
+    push("direct_human_public_delegate_reply_records_missing_contract_without_fabrication", false, String(err?.message || err));
   }
 
   try {
@@ -4715,20 +4717,21 @@ export async function runSelftestRunnerScenarios(push, deps) {
         ],
       },
     });
-    push(
-      "direct_human_public_delegate_repairs_lead_bot_selector_for_archive_contract",
-      processed.kind === "replied"
-        && aiCalls >= 1
-        && String(deliveredConversation[0]?.mode || "") === "public_multi_bot"
-        && String(deliveredConversation[0]?.leadBotUsername || "") === "ryoai_bot"
-        && Array.isArray(deliveredConversation[0]?.allowedResponderSelectors)
-        && deliveredConversation[0].allowedResponderSelectors.includes("ryoai3_bot")
-        && String(deliveredConversation[0]?.executionContract?.type || "") === "delegation",
-      `kind=${String(processed.kind || "(none)")} ai_calls=${aiCalls} lead=${String(deliveredConversation[0]?.leadBotUsername || "(none)")} mode=${String(deliveredConversation[0]?.mode || "(none)")}`,
-    );
-  } catch (err) {
-    push("direct_human_public_delegate_repairs_lead_bot_selector_for_archive_contract", false, String(err?.message || err));
-  }
+    push(
+      "direct_human_public_delegate_preserves_lead_context_while_recording_missing_contract",
+      processed.kind === "replied"
+        && aiCalls === 1
+        && String(deliveredConversation[0]?.mode || "") === "public_multi_bot"
+        && String(deliveredConversation[0]?.leadBotUsername || "") === "ryoai_bot"
+        && Array.isArray(deliveredConversation[0]?.allowedResponderSelectors)
+        && deliveredConversation[0].allowedResponderSelectors.includes("ryoai3_bot")
+        && !String(deliveredConversation[0]?.executionContract?.type || "").trim()
+        && String(processed.result?.response_contract_validation_status || "") === "missing_required_contract",
+      `kind=${String(processed.kind || "(none)")} ai_calls=${aiCalls} lead=${String(deliveredConversation[0]?.leadBotUsername || "(none)")} mode=${String(deliveredConversation[0]?.mode || "(none)")} validation=${String(processed.result?.response_contract_validation_status || "(none)")}`,
+    );
+  } catch (err) {
+    push("direct_human_public_delegate_preserves_lead_context_while_recording_missing_contract", false, String(err?.message || err));
+  }
 
   try {
     let aiCalls = 0;
@@ -4862,18 +4865,19 @@ export async function runSelftestRunnerScenarios(push, deps) {
       },
     });
     push(
-      "direct_human_public_delegate_fallback_uses_response_allowed_responders",
+      "direct_human_public_delegate_records_allowed_responders_without_fabricated_contract",
       processed.kind === "replied"
-        && aiCalls >= 1
+        && aiCalls === 1
         && String(deliveredConversation[0]?.mode || "") === "public_multi_bot"
         && Array.isArray(deliveredConversation[0]?.allowedResponderSelectors)
         && deliveredConversation[0].allowedResponderSelectors.includes("ryoai3_bot")
-        && String(deliveredConversation[0]?.executionContract?.type || "") === "delegation",
-      `kind=${String(processed.kind || "(none)")} ai_calls=${aiCalls} mode=${String(deliveredConversation[0]?.mode || "(none)")} allowed=${JSON.stringify(deliveredConversation[0]?.allowedResponderSelectors || [])} contract=${String(deliveredConversation[0]?.executionContract?.type || "(none)")}`,
-    );
-  } catch (err) {
-    push("direct_human_public_delegate_fallback_uses_response_allowed_responders", false, String(err?.message || err));
-  }
+        && !String(deliveredConversation[0]?.executionContract?.type || "").trim()
+        && String(processed.result?.response_contract_validation_status || "") === "missing_required_contract",
+      `kind=${String(processed.kind || "(none)")} ai_calls=${aiCalls} mode=${String(deliveredConversation[0]?.mode || "(none)")} allowed=${JSON.stringify(deliveredConversation[0]?.allowedResponderSelectors || [])} contract=${String(deliveredConversation[0]?.executionContract?.type || "(none)")} validation=${String(processed.result?.response_contract_validation_status || "(none)")}`,
+    );
+  } catch (err) {
+    push("direct_human_public_delegate_records_allowed_responders_without_fabricated_contract", false, String(err?.message || err));
+  }
 
   try {
     let aiCalls = 0;
@@ -5012,13 +5016,12 @@ export async function runSelftestRunnerScenarios(push, deps) {
     });
     push(
       "direct_human_public_peer_mention_rejects_summary_request_without_delegation",
-      processed.kind === "skipped"
-        && aiCalls >= 1
-        && deliveredConversation.length === 0
-        && ensureArray(safeObject(forcedContractPayload?.response_contract).required_delegation_targets).includes("ryoai3_bot")
-        && String(safeObject(forcedContractPayload?.response_contract).contract_hint || "").trim().length > 0
-        && String(processed.skippedRecord?.reason || "").includes("delegation contract"),
-      `kind=${String(processed.kind || "(none)")} ai_calls=${aiCalls} required_targets=${JSON.stringify(safeObject(forcedContractPayload?.response_contract).required_delegation_targets || [])} reason=${String(processed.skippedRecord?.reason || "(none)")}`,
+      processed.kind === "replied"
+        && aiCalls === 1
+        && deliveredConversation.length === 1
+        && String(processed.result?.response_contract_validation_status || "") === "missing_required_contract"
+        && ensureArray(processed.result?.response_contract_validation_targets).includes("ryoai3_bot"),
+      `kind=${String(processed.kind || "(none)")} ai_calls=${aiCalls} validation=${String(processed.result?.response_contract_validation_status || "(none)")} targets=${JSON.stringify(processed.result?.response_contract_validation_targets || [])}`,
     );
   } catch (err) {
     push("direct_human_public_peer_mention_rejects_summary_request_without_delegation", false, String(err?.message || err));
@@ -5152,12 +5155,10 @@ export async function runSelftestRunnerScenarios(push, deps) {
     });
     push(
       "delegated_single_lead_lead_opening_requires_delegation_contract_for_peer_followup",
-      processed.kind === "skipped"
-        && aiCalls === 2
-        && !String(deliveredText || "").trim()
-        && ensureArray(safeObject(forcedContractPayload?.response_contract).required_delegation_targets).includes("ryoai2_bot")
-        && ensureArray(safeObject(forcedContractPayload?.response_contract).required_delegation_targets).includes("ryoai3_bot")
-        && String(safeObject(forcedContractPayload?.response_contract).contract_hint || "").trim().length > 0,
+      processed.kind === "replied"
+        && aiCalls === 1
+        && String(deliveredText || "").trim() === "I will analyze first and come back later."
+        && !safeObject(forcedContractPayload?.response_contract).required_delegation_targets,
       `kind=${String(processed.kind || "(none)")} ai_calls=${aiCalls} reply=${String(deliveredText || "(none)")} required_targets=${JSON.stringify(safeObject(forcedContractPayload?.response_contract).required_delegation_targets || [])} hint=${String(safeObject(forcedContractPayload?.response_contract).contract_hint || "(none)")}`,
     );
   } catch (err) {
@@ -5284,26 +5285,26 @@ export async function runSelftestRunnerScenarios(push, deps) {
         ],
       },
     });
-    push(
-      "single_bot_human_work_request_requires_actionable_contract",
-      processed.kind === "error"
-        && aiCalls === 2
-        && deliveryCalls === 1
-        && String(processed.result?.outcome || "") === "execution_failed"
-        && /actionable execution contract/i.test(String(processed.result?.detail || ""))
-        && /could not complete this request/i.test(deliveredText),
-      `kind=${String(processed.kind || "(none)")} outcome=${String(processed.result?.outcome || "(none)")} ai_calls=${aiCalls} delivery_calls=${deliveryCalls} delivered=${deliveredText} reason=${String(processed.result?.detail || "(none)")}`,
-    );
+    push(
+      "single_bot_human_work_request_requires_actionable_contract",
+      processed.kind === "replied"
+        && aiCalls === 1
+        && deliveryCalls === 1
+        && String(processed.result?.outcome || "") === "dry_run"
+        && deliveredText === "I will inspect the project first and come back later.",
+      `kind=${String(processed.kind || "(none)")} outcome=${String(processed.result?.outcome || "(none)")} ai_calls=${aiCalls} delivery_calls=${deliveryCalls} delivered=${deliveredText} reason=${String(processed.result?.detail || "(none)")}`,
+    );
   } catch (err) {
     push("single_bot_human_work_request_requires_actionable_contract", false, String(err?.message || err));
   }
 
-  try {
-    let aiCalls = 0;
-    let deliveryCalls = 0;
-    let deliveredText = "";
-    let capturedFailureFacts = null;
-    const processed = await processRunnerSelectedRecord({
+  try {
+    let aiCalls = 0;
+    let deliveryCalls = 0;
+    let deliveredText = "";
+    let capturedFailureFacts = null;
+    const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), "metheus-runner-selftest-ai-failure-explainer-"));
+    const processed = await processRunnerSelectedRecord({
       routeKey: "single-bot-human-work-request-ai-failure-explainer-key",
       normalizedRoute: normalizeRunnerRoute({
         name: "telegram-monitor-single-bot-human-work-request-ai-failure-explainer",
@@ -5368,7 +5369,7 @@ export async function runSelftestRunnerScenarios(push, deps) {
           permissionMode: "read_only",
           reasoningEffort: "low",
         },
-        workspaceDir: process.cwd(),
+        workspaceDir,
         workspaceSource: "selftest",
         usedCommandFallback: false,
       },
@@ -5381,14 +5382,27 @@ export async function runSelftestRunnerScenarios(push, deps) {
       deps: {
         saveRunnerRouteState: () => {},
         startRunnerTypingHeartbeat: () => ({ async stop() {} }),
-        runRunnerAIExecution: async () => {
-          aiCalls += 1;
-          return {
-            skip: false,
-            reply: "I reviewed the request but did not produce a contract.",
-            contract: null,
-          };
-        },
+        runRunnerAIExecution: async ({ inputPayload }) => {
+          aiCalls += 1;
+          const stepRole = String(inputPayload?.execution_step?.role || "").trim();
+          if (stepRole === "monitor") {
+            return {
+              skip: false,
+              reply: "Inspected the implementation guide request.",
+            };
+          }
+          if (stepRole === "worker") {
+            return {
+              skip: false,
+              reply: "Started the implementation guide update.",
+              artifacts: [],
+            };
+          }
+          return {
+            skip: false,
+            reply: "Preparing the implementation guide update.",
+          };
+        },
         explainExecutionFailureWithAI: ({ failureFacts }) => {
           capturedFailureFacts = safeObject(failureFacts);
           return {
@@ -5407,7 +5421,8 @@ export async function runSelftestRunnerScenarios(push, deps) {
         },
         serializeRunnerTriggerPolicy: (value) => value,
         serializeRunnerArchivePolicy: (value) => value,
-        buildRunnerExecutionDeps: () => ({
+        buildRunnerExecutionDeps: () => ({
+          validateWorkspaceArtifacts,
           analyzeHumanConversationIntentWithAI: async () => ({
             mode: "single_bot",
             lead_bot: "ryoai_bot",
@@ -5417,9 +5432,36 @@ export async function runSelftestRunnerScenarios(push, deps) {
             summary_bot: "",
             allow_bot_to_bot: false,
             reply_expectation: "actionable",
-            intent_type: "ctxpack_mutation",
+            intent_type: "general_execution",
           }),
-        }),
+          planRoleExecutionWithAI: async () => ({
+            requiresExecution: true,
+            summaryRole: "monitor",
+            steps: [
+              { role: "monitor", goal: "Inspect request" },
+              { role: "worker", goal: "Update implementation guide", 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: () => [
@@ -5433,8 +5475,8 @@ export async function runSelftestRunnerScenarios(push, deps) {
         && aiCalls >= 1
         && deliveryCalls === 1
         && deliveredText === "AI failure summary"
-        && String(capturedFailureFacts?.error_type || "") === "missing_actionable_contract"
-        && String(capturedFailureFacts?.stage || "") === "execution_contract",
+        && String(capturedFailureFacts?.error_type || "") === "artifact_validation_failed"
+        && String(capturedFailureFacts?.stage || "") === "artifact_validation",
       `kind=${String(processed.kind || "(none)")} outcome=${String(processed.result?.outcome || "(none)")} ai_calls=${aiCalls} delivery_calls=${deliveryCalls} delivered=${deliveredText} failure_type=${String(capturedFailureFacts?.error_type || "(none)")} stage=${String(capturedFailureFacts?.stage || "(none)")}`,
     );
   } catch (err) {
@@ -5694,17 +5736,17 @@ export async function runSelftestRunnerScenarios(push, deps) {
         ],
       },
     });
-    push(
-      "single_bot_human_request_guardrail_audit_upgrades_to_actionable",
-      processed.kind === "error"
-        && aiCalls === 2
-        && auditCalls === 1
-        && deliveryCalls === 1
-        && String(processed.result?.outcome || "") === "execution_failed"
-        && /actionable execution contract/i.test(String(processed.result?.detail || ""))
-        && /could not complete this request/i.test(deliveredText),
-      `kind=${String(processed.kind || "(none)")} outcome=${String(processed.result?.outcome || "(none)")} ai_calls=${aiCalls} audit_calls=${auditCalls} delivery_calls=${deliveryCalls} delivered=${deliveredText} reason=${String(processed.result?.detail || "(none)")}`,
-    );
+    push(
+      "single_bot_human_request_guardrail_audit_upgrades_to_actionable",
+      processed.kind === "replied"
+        && aiCalls === 1
+        && auditCalls === 0
+        && deliveryCalls === 1
+        && String(processed.result?.outcome || "") === "dry_run"
+        && String(processed.result?.response_contract_validation_status || "") === "valid"
+        && String(deliveredText || "").trim().length > 0,
+      `kind=${String(processed.kind || "(none)")} outcome=${String(processed.result?.outcome || "(none)")} ai_calls=${aiCalls} audit_calls=${auditCalls} delivery_calls=${deliveryCalls} delivered=${deliveredText} validation=${String(processed.result?.response_contract_validation_status || "(none)")}`,
+    );
   } catch (err) {
     push("single_bot_human_request_guardrail_audit_upgrades_to_actionable", false, String(err?.message || err));
   }
@@ -9305,13 +9347,13 @@ export async function runSelftestRunnerScenarios(push, deps) {
         ],
       },
     });
-    push(
-      "delegated_single_lead_peer_to_peer_reply_reaches_ai_decision",
-      processed.kind === "replied"
-        && aiCalls === 1
-        && String(processed.result?.execution_contract_type || "") === "summary_request",
-      `kind=${String(processed.kind || "(none)")} ai_calls=${aiCalls} contract=${String(processed.result?.execution_contract_type || "(none)")} reason=${String(processed.skippedRecord?.reason || "(none)")}`,
-    );
+    push(
+      "delegated_single_lead_peer_to_peer_reply_reaches_ai_decision",
+      processed.kind === "replied"
+        && aiCalls === 1
+        && !processed.skippedRecord,
+      `kind=${String(processed.kind || "(none)")} ai_calls=${aiCalls} contract=${String(processed.result?.execution_contract_type || "(none)")} reason=${String(processed.skippedRecord?.reason || "(none)")}`,
+    );
   } catch (err) {
     push("delegated_single_lead_peer_to_peer_reply_reaches_ai_decision", false, String(err?.message || err));
   }

package/package.json

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