metheus-governance-mcp-cli 0.2.212 → 0.2.213

package/cli.mjs

@@ -2358,6 +2358,16 @@ function normalizeBotRunnerRequests(rawRequests, nowMs = Date.now()) {
       next_expected_responders: ensureArray(entry.next_expected_responders || entry.nextExpectedResponders)
         .map((value) => normalizeTelegramMentionUsername(value))
         .filter(Boolean),
+      ai_reply_generated: boolFromRaw(
+        entry.ai_reply_generated ?? entry.aiReplyGenerated,
+        false,
+      ),
+      ai_reply_generated_at: firstNonEmptyString([entry.ai_reply_generated_at, entry.aiReplyGeneratedAt]),
+      ai_reply_preview: String(entry.ai_reply_preview || entry.aiReplyPreview || "").trim(),
+      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(),
+      archive_error: String(entry.archive_error || entry.archiveError || "").trim(),
       normalized_intent: String(entry.normalized_intent || entry.normalizedIntent || "").trim().toLowerCase(),
       status,
       claimed_by_route: String(entry.claimed_by_route || entry.claimedByRoute || "").trim(),
@@ -4482,6 +4492,13 @@ function markRunnerRequestLifecycle({
   conversationReplyExpectation = "",
   normalizedIntent = "",
   closedReason = "",
+  aiReplyGenerated = false,
+  aiReplyGeneratedAt = "",
+  aiReplyPreview = "",
+  deliveryStatus = "",
+  archiveStatus = "",
+  transportError = "",
+  archiveError = "",
 }) {
   const key = String(requestKey || "").trim();
   if (!key) return null;
@@ -4531,6 +4548,7 @@ function markRunnerRequestLifecycle({
   const nextStatus = (() => {
     if (normalizedOutcome === "claimed") return "claimed";
     if (normalizedOutcome === "running") return "running";
+    if (normalizedOutcome === "delivery_failed_after_generation") return "running";
     if (normalizedOutcome === "replied") {
       return shouldRemainRunningAfterReply ? "running" : "completed";
     }
@@ -4587,6 +4605,15 @@ function markRunnerRequestLifecycle({
       ensureArray(nextExpectedResponders).length ? nextExpectedResponders : existing.next_expected_responders,
       normalizeTelegramMentionUsername,
     ),
+    ai_reply_generated: aiReplyGenerated === true || existing.ai_reply_generated === true,
+    ai_reply_generated_at: aiReplyGenerated === true
+      ? 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(),
+    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(),
+    archive_error: String(archiveError || existing.archive_error || "").trim(),
     normalized_intent: nextNormalizedIntent,
     status: nextStatus,
     started_at: firstNonEmptyString([existing.started_at, nowISO]),
@@ -8741,7 +8768,9 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
           requestKey: requestClaim.requestKey,
           selectedRecord,
           routeKey,
-          outcome: String(processed.result?.outcome || "replied").trim().toLowerCase(),
+          outcome: processed.kind === "delivery_failed"
+            ? "delivery_failed_after_generation"
+            : String(processed.result?.outcome || "replied").trim().toLowerCase(),
           conversationIDRaw: String(processed.result?.conversation_id || "").trim(),
           conversationParticipants: ensureArray(processed.result?.conversation_participants),
           conversationInitialResponders: ensureArray(processed.result?.conversation_initial_responders),
@@ -8757,14 +8786,23 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
           currentBotSelector,
           conversationIntentMode: String(processed.result?.conversation_intent_mode || "").trim(),
           normalizedIntent: resolvedIntentType,
+          aiReplyGenerated: processed.result?.ai_reply_generated === true,
+          aiReplyGeneratedAt: String(processed.result?.ai_reply_generated_at || "").trim(),
+          aiReplyPreview: String(processed.result?.ai_reply_preview || "").trim(),
+          deliveryStatus: String(processed.result?.delivery_status || "").trim(),
+          archiveStatus: String(processed.result?.archive_status || "").trim(),
+          transportError: String(processed.result?.transport_error || "").trim(),
+          archiveError: String(processed.result?.archive_error || "").trim(),
         });
-        await ensureRunnerRootWorkItemForRequest({
-          normalizedRoute,
-          routeKey,
-          selectedRecord,
-          runtime,
-          requestKey: requestClaim.requestKey,
-        });
+        if (processed.kind !== "delivery_failed") {
+          await ensureRunnerRootWorkItemForRequest({
+            normalizedRoute,
+            routeKey,
+            selectedRecord,
+            runtime,
+            requestKey: requestClaim.requestKey,
+          });
+        }
         const rootWorkItemSync = await syncRunnerRequestRootWorkItemForOutcome({
           normalizedRoute,
           runtime,
@@ -11143,7 +11181,9 @@ async function runRunnerStartResolvedRoutes(routes, flags, options = {}) {
                         requestKey: deferredExecution.requestKey,
                         selectedRecord: deferredExecution.selectedRecord,
                         routeKey: deferredExecution.routeKey,
-                        outcome: String(processed.result?.outcome || "replied").trim().toLowerCase(),
+                        outcome: processed.kind === "delivery_failed"
+                          ? "delivery_failed_after_generation"
+                          : String(processed.result?.outcome || "replied").trim().toLowerCase(),
                         conversationIDRaw: String(processed.result?.conversation_id || "").trim(),
                         conversationParticipants: ensureArray(processed.result?.conversation_participants),
                         conversationInitialResponders: ensureArray(processed.result?.conversation_initial_responders),
@@ -11161,14 +11201,23 @@ async function runRunnerStartResolvedRoutes(routes, flags, options = {}) {
                         ),
                         conversationIntentMode: String(processed.result?.conversation_intent_mode || "").trim(),
                         normalizedIntent: resolvedIntentType,
+                        aiReplyGenerated: processed.result?.ai_reply_generated === true,
+                        aiReplyGeneratedAt: String(processed.result?.ai_reply_generated_at || "").trim(),
+                        aiReplyPreview: String(processed.result?.ai_reply_preview || "").trim(),
+                        deliveryStatus: String(processed.result?.delivery_status || "").trim(),
+                        archiveStatus: String(processed.result?.archive_status || "").trim(),
+                        transportError: String(processed.result?.transport_error || "").trim(),
+                        archiveError: String(processed.result?.archive_error || "").trim(),
                       });
-                      await ensureRunnerRootWorkItemForRequest({
-                        normalizedRoute: deferredExecution.normalizedRoute,
-                        routeKey: deferredExecution.routeKey,
-                        selectedRecord: deferredExecution.selectedRecord,
-                        runtime: deferredExecution.runtime,
-                        requestKey: deferredExecution.requestKey,
-                      });
+                      if (processed.kind !== "delivery_failed") {
+                        await ensureRunnerRootWorkItemForRequest({
+                          normalizedRoute: deferredExecution.normalizedRoute,
+                          routeKey: deferredExecution.routeKey,
+                          selectedRecord: deferredExecution.selectedRecord,
+                          runtime: deferredExecution.runtime,
+                          requestKey: deferredExecution.requestKey,
+                        });
+                      }
                       const rootWorkItemSync = await syncRunnerRequestRootWorkItemForOutcome({
                         normalizedRoute: deferredExecution.normalizedRoute,
                         runtime: deferredExecution.runtime,

package/lib/local-ai-adapters.mjs

@@ -1657,6 +1657,9 @@ 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 agentContext = safePayload.agent_context && typeof safePayload.agent_context === "object"
+    ? safePayload.agent_context
+    : null;
   const trigger = safePayload.trigger && typeof safePayload.trigger === "object" ? safePayload.trigger : {};
   const responseContract = safePayload.response_contract && typeof safePayload.response_contract === "object"
     ? safePayload.response_contract
@@ -1786,6 +1789,9 @@ export function buildLocalBotPrompt(payload, { terse = true } = {}) {
     "Current turn purpose:",
     currentTurnPurpose,
     "",
+    "Agent contract/context blob (primary control and state input):",
+    agentContext ? JSON.stringify(agentContext, null, 2) : "-",
+    "",
     "Current user request:",
     String(trigger.body || "").trim() || "-",
     "",

package/lib/runner-orchestration.mjs

@@ -5406,55 +5406,114 @@ export async function processRunnerSelectedRecord({
           messageID: intFromRawAllowZero(selectedRecord?.parsedArchive?.messageID, 0),
         },
       };
-    }
-  }
+    }
+  }
+  const aiReplyGeneratedAt = new Date().toISOString();
+  const aiReplyPreview = String(sanitizedReplyText || "").replace(/\s+/g, " ").trim().slice(0, 280);
   emitRunnerStage("delivering", "sending reply and mirroring archive");
-  const deliveryResult = await performLocalBotDelivery({
-    siteBaseURL: runtime.baseURL,
-    token: runtime.token,
-    timeoutSeconds: runtime.timeoutSeconds,
-    actorUserID: runtime.actor.user_id,
-    bot: {
-      id: bot.id,
-      name: bot.name,
-      username: bot.username,
-      role: bot.role,
-      provider: bot.provider,
-    },
-    projectID: normalizedRoute.projectID,
-    provider: normalizedRoute.provider,
-    destinationSelectors: {
-      destinationID: destination.id,
-      destinationLabel: destination.label,
-    },
-    text: sanitizedReplyText,
-    disableWebPagePreview: true,
-    replyToMessageID,
-    archiveReplies: normalizedRoute.archivePolicy.mirrorReplies,
-    archiveDedupeOutbound: normalizedRoute.archivePolicy.dedupeOutbound,
-    archiveThreadID: archiveThread.threadID,
-    archiveWorkItemID: archiveThread.workItemID,
-    archiveConversation: effectiveConversationContext
-      ? {
-          id: effectiveConversationContext.id,
-          mode: effectiveConversationContext.mode,
-          stage: effectiveConversationContext.stage,
-          intentMode: effectiveConversationContext.intentMode,
-          allowBotToBot: effectiveConversationContext.allowBotToBot === true,
-          leadBotUsername: effectiveConversationContext.leadBotUsername,
-          summaryBotUsername: effectiveConversationContext.summaryBotUsername,
-          participants: effectiveConversationContext.participantSelectors,
-          participantSelectors: effectiveConversationContext.participantSelectors,
-          initialResponders: effectiveConversationContext.initialResponderSelectors,
-          initialResponderSelectors: effectiveConversationContext.initialResponderSelectors,
-          allowedResponders: effectiveConversationContext.allowedResponderSelectors,
-          allowedResponderSelectors: effectiveConversationContext.allowedResponderSelectors,
-          executionContract,
-        }
-      : null,
-    dryRun: normalizedRoute.dryRunDelivery,
-    deps: buildRunnerDeliveryDeps(),
-  });
+  let deliveryResult;
+  try {
+    deliveryResult = await performLocalBotDelivery({
+      siteBaseURL: runtime.baseURL,
+      token: runtime.token,
+      timeoutSeconds: runtime.timeoutSeconds,
+      actorUserID: runtime.actor.user_id,
+      bot: {
+        id: bot.id,
+        name: bot.name,
+        username: bot.username,
+        role: bot.role,
+        provider: bot.provider,
+      },
+      projectID: normalizedRoute.projectID,
+      provider: normalizedRoute.provider,
+      destinationSelectors: {
+        destinationID: destination.id,
+        destinationLabel: destination.label,
+      },
+      text: sanitizedReplyText,
+      disableWebPagePreview: true,
+      replyToMessageID,
+      archiveReplies: normalizedRoute.archivePolicy.mirrorReplies,
+      archiveDedupeOutbound: normalizedRoute.archivePolicy.dedupeOutbound,
+      archiveThreadID: archiveThread.threadID,
+      archiveWorkItemID: archiveThread.workItemID,
+      archiveConversation: effectiveConversationContext
+        ? {
+            id: effectiveConversationContext.id,
+            mode: effectiveConversationContext.mode,
+            stage: effectiveConversationContext.stage,
+            intentMode: effectiveConversationContext.intentMode,
+            allowBotToBot: effectiveConversationContext.allowBotToBot === true,
+            leadBotUsername: effectiveConversationContext.leadBotUsername,
+            summaryBotUsername: effectiveConversationContext.summaryBotUsername,
+            participants: effectiveConversationContext.participantSelectors,
+            participantSelectors: effectiveConversationContext.participantSelectors,
+            initialResponders: effectiveConversationContext.initialResponderSelectors,
+            initialResponderSelectors: effectiveConversationContext.initialResponderSelectors,
+            allowedResponders: effectiveConversationContext.allowedResponderSelectors,
+            allowedResponderSelectors: effectiveConversationContext.allowedResponderSelectors,
+            executionContract,
+          }
+        : null,
+      dryRun: normalizedRoute.dryRunDelivery,
+      deps: buildRunnerDeliveryDeps(),
+    });
+  } catch (err) {
+    const transportError = String(err?.message || err).trim() || "delivery_failed";
+    saveRunnerRouteState(
+      routeKey,
+      buildRunnerRouteStateFromComment(selectedRecord, {
+        last_action: "delivery_failed_after_generation",
+        last_reason: transportError,
+        last_trigger: String(effectiveTriggerDecision.trigger || "").trim(),
+        last_conversation_id: String(effectiveConversationContext?.id || "").trim(),
+        last_conversation_stage: String(effectiveConversationContext?.stage || "").trim(),
+        last_speaker_bot_username: normalizeMentionSelector(bot?.username || bot?.name),
+        last_workspace_dir: String(effectiveExecutionPlan.workspaceDir || "").trim(),
+        ...intentStatePatch,
+      }),
+    );
+    return {
+      kind: "delivery_failed",
+      result: {
+        route_key: routeKey,
+        route_name: normalizedRoute.name,
+        outcome: "delivery_failed_after_generation",
+        detail: `ai reply generated but delivery failed (${transportError})`,
+        thread_id: archiveThread.threadID,
+        comment_id: selectedRecord.id,
+        trigger_kind: String(effectiveTriggerDecision.trigger || "").trim(),
+        conversation_id: String(effectiveConversationContext?.id || "").trim(),
+        conversation_stage: String(effectiveConversationContext?.stage || "").trim(),
+        conversation_intent_mode: String(effectiveConversationContext?.intentMode || "").trim(),
+        conversation_lead_bot: String(effectiveConversationContext?.leadBotUsername || "").trim(),
+        conversation_summary_bot: String(effectiveConversationContext?.summaryBotUsername || "").trim(),
+        conversation_participants: ensureArray(effectiveConversationContext?.participantSelectors),
+        conversation_initial_responders: ensureArray(effectiveConversationContext?.initialResponderSelectors),
+        conversation_allowed_responders: ensureArray(effectiveConversationContext?.allowedResponderSelectors),
+        conversation_allow_bot_to_bot: effectiveConversationContext?.allowBotToBot === true,
+        conversation_reply_expectation: String(effectiveConversationContext?.replyExpectation || "").trim(),
+        execution_contract_type: String(executionContract?.type || "").trim(),
+        execution_contract_actionable: executionContract?.actionable === true,
+        execution_contract_targets: ensureArray(executionContract?.assignments).map((item) => normalizeMentionSelector(item.targetBot)).filter(Boolean),
+        next_expected_responders: collectExecutionContractNextResponders(executionContract),
+        artifact_validation: String(artifactValidation.status || "").trim() || "none",
+        artifact_paths: summarizeValidatedArtifactPaths(artifactValidation),
+        ai_reply_generated: true,
+        ai_reply_generated_at: aiReplyGeneratedAt,
+        ai_reply_preview: aiReplyPreview,
+        delivery_status: "failed_transport",
+        archive_status: "not_attempted",
+        transport_error: transportError,
+        archive_error: "",
+        reply_chars: String(sanitizedReplyText || "").length,
+        execution_mode: effectiveExecutionPlan.mode,
+        role_profile: effectiveExecutionPlan.roleProfileName,
+        executed_role_plan: executedRolePlan && Object.keys(executedRolePlan).length > 0 ? executedRolePlan : undefined,
+      },
+    };
+  }
   emitRunnerStage("context_suggesting", "evaluating shared project context suggestion");
   const projectContextSuggestion = await maybeCreateSuggestedProjectContext({
     aiResult,
@@ -5629,6 +5688,10 @@ export async function processRunnerSelectedRecord({
       evidence_ids: ensureArray(aiResult?.evidenceItems).map((item) => String(safeObject(item).id || "").trim()).filter(Boolean),
       evidence_paths: ensureArray(aiResult?.evidenceItems).map((item) => String(safeObject(item).path || "").trim()).filter(Boolean),
       reply_chars: String(sanitizedReplyText || "").length,
+      ai_reply_generated: true,
+      ai_reply_generated_at: aiReplyGeneratedAt,
+      ai_reply_preview: aiReplyPreview,
+      delivery_status: deliveryResult.delivery.dryRun ? "dry_run" : "delivered",
       execution_mode: effectiveExecutionPlan.mode,
       role_profile: effectiveExecutionPlan.roleProfileName,
       executed_role_plan: executedRolePlan && Object.keys(executedRolePlan).length > 0 ? executedRolePlan : undefined,

package/lib/runner-trigger.mjs

@@ -94,19 +94,7 @@ function buildTriggerCandidateBotUsernames(parsedArchive) {
 function buildRunnerTaskName(humanIntentType, humanIntentContract = null) {
   const normalizedIntentType = String(humanIntentType || "").trim().toLowerCase();
   const contract = safeObject(humanIntentContract);
-  const replyExpectation = String(contract.replyExpectation || contract.reply_expectation || "").trim().toLowerCase();
   const executionContractType = String(contract.executionContractType || contract.execution_contract_type || "").trim().toLowerCase();
-  const intentMode = String(contract.intentMode || contract.intent_mode || "").trim().toLowerCase();
-  const executionIntentRequested = [
-    "general_execution",
-    "ctxpack_mutation",
-    "workitem_mutation",
-  ].includes(normalizedIntentType);
-  const collaborativeIntentMode = [
-    "delegated_single_lead",
-    "multi_bot_collab",
-    "multi_bot_direct",
-  ].includes(intentMode);
   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";
@@ -115,12 +103,6 @@ function buildRunnerTaskName(humanIntentType, humanIntentContract = null) {
   if (executionContractType) {
     return "reply_to_project_actionable_message";
   }
-  if (collaborativeIntentMode && replyExpectation === "actionable") {
-    return "reply_to_project_chat_message";
-  }
-  if (executionIntentRequested) {
-    return "reply_to_project_actionable_message";
-  }
   return "reply_to_project_chat_message";
 }
 
@@ -199,6 +181,9 @@ export function buildRunnerInputPayload({
   const directHumanIntent = safeObject(humanIntentContract);
   const safeDirectQueryReply = safeObject(directQueryReply);
   const candidateBotUsernames = buildTriggerCandidateBotUsernames(parsed);
+  const executionContractType = String(
+    directHumanIntent.executionContractType || directHumanIntent.execution_contract_type || "",
+  ).trim().toLowerCase();
   return {
     task: buildRunnerTaskName(directHumanIntent.intentType, directHumanIntent),
     project_id: String(route?.projectID || "").trim(),
@@ -279,6 +264,39 @@ export function buildRunnerInputPayload({
       require_actionable_contract: directHumanIntent.requiresActionableContract === true,
       allowed_contract_types: ensureArray(directHumanIntent.allowedContractTypes),
     },
+    agent_context: {
+      bot_identity: {
+        id: String(bot?.id || "").trim(),
+        name: String(bot?.name || "").trim(),
+        username: String(bot?.username || "").trim(),
+        role: String(bot?.role || route?.role || "").trim(),
+      },
+      request_facts: {
+        comment_id: selectedRecord?.id,
+        trigger_kind: String(triggerDecision?.trigger || "").trim(),
+        body: String(parsed.body || "").trim(),
+        message_id: Number.parseInt(String(parsed.messageID ?? 0), 10) || 0,
+        reply_to_message_id: Number.parseInt(String(parsed.replyToMessageID ?? 0), 10) || 0,
+      },
+      conversation_contract: {
+        conversation_id: String(directHumanIntent.conversationID || directHumanIntent.conversation_id || parsed.conversationID || "").trim(),
+        mode: String(directHumanIntent.intentMode || directHumanIntent.intent_mode || "").trim(),
+        intent_type: String(directHumanIntent.intentType || directHumanIntent.intent_type || "").trim(),
+        lead_bot: String(directHumanIntent.leadBotSelector || directHumanIntent.lead_bot || "").trim(),
+        summary_bot: String(directHumanIntent.summaryBotSelector || directHumanIntent.summary_bot || "").trim(),
+        participants: ensureArray(directHumanIntent.participantSelectors || directHumanIntent.participants),
+        initial_responders: ensureArray(directHumanIntent.initialResponderSelectors || directHumanIntent.initial_responders),
+        allowed_responders: ensureArray(directHumanIntent.allowedResponderSelectors || directHumanIntent.allowed_responders),
+        reply_expectation: String(directHumanIntent.replyExpectation || directHumanIntent.reply_expectation || "").trim(),
+        execution_contract_type: executionContractType,
+      },
+      validation_contract: {
+        current_bot_is_candidate: true,
+        require_actionable_contract: directHumanIntent.requiresActionableContract === true,
+        allowed_contract_types: ensureArray(directHumanIntent.allowedContractTypes),
+        candidate_bot_usernames: candidateBotUsernames,
+      },
+    },
     conversation: conversationContext
       ? {
           mode: String(conversationContext.mode || "").trim(),

package/lib/selftest-runner-scenarios.mjs

@@ -11985,12 +11985,133 @@ export async function runSelftestRunnerScenarios(push, deps) {
         && !/project-operating-guide\.md/i.test(deliveredText),
       `kind=${String(processed.kind || "(none)")} outcome=${String(processed.result?.outcome || "(none)")} delivery_calls=${deliveryCalls} delivered=${deliveredText} detail=${String(processed.result?.detail || "(none)")}`,
     );
-  } catch (err) {
-    push("runner_direct_failure_reply_uses_generic_message_for_unobserved_reported_artifacts", false, String(err?.message || err));
-  }
-
-  try {
-    const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), "metheus-runner-selftest-observed-artifacts-"));
+  } catch (err) {
+    push("runner_direct_failure_reply_uses_generic_message_for_unobserved_reported_artifacts", false, String(err?.message || err));
+  }
+
+  try {
+    const processed = await processRunnerSelectedRecord({
+      routeKey: "delivery-failed-after-generation-key",
+      normalizedRoute: normalizeRunnerRoute({
+        name: "telegram-monitor-delivery-failed-after-generation",
+        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-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: false,
+      }),
+      selectedRecord: {
+        id: "comment-delivery-failed-after-generation",
+        createdAt: "2026-03-17T00:00:21.000Z",
+        parsedArchive: {
+          kind: "telegram_message",
+          chatID: "-100123",
+          chatType: "supergroup",
+          body: "@RyoAI_bot hi",
+          messageID: 126,
+          sender: "human",
+          senderIsBot: false,
+          mentionUsernames: ["ryoai_bot"],
+        },
+      },
+      pendingOrdered: [],
+      bot: {
+        id: "bot-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 () => ({
+          skip: false,
+          reply: "Hello from RyoAI_bot.",
+        }),
+        performLocalBotDelivery: async () => {
+          throw new Error("read ECONNRESET");
+        },
+        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: "informational",
+            intent_type: "small_talk",
+          }),
+        }),
+        buildRunnerDeliveryDeps: () => ({}),
+        buildRunnerRuntimeDeps: () => ({}),
+        resolveConversationPeerBots: () => [],
+      },
+    });
+    push(
+      "runner_delivery_failure_after_generation_records_ai_state_without_execution_error",
+      processed.kind === "delivery_failed"
+        && String(processed.result?.outcome || "") === "delivery_failed_after_generation"
+        && processed.result?.ai_reply_generated === true
+        && String(processed.result?.delivery_status || "") === "failed_transport"
+        && /ECONNRESET/i.test(String(processed.result?.transport_error || "")),
+      `kind=${String(processed.kind || "(none)")} outcome=${String(processed.result?.outcome || "(none)")} ai_generated=${String(processed.result?.ai_reply_generated || false)} delivery=${String(processed.result?.delivery_status || "(none)")} transport=${String(processed.result?.transport_error || "(none)")}`,
+    );
+  } catch (err) {
+    push("runner_delivery_failure_after_generation_records_ai_state_without_execution_error", false, String(err?.message || err));
+  }
+
+  try {
+    const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), "metheus-runner-selftest-observed-artifacts-"));
     const scriptDir = path.join(workspaceDir, ".metheus", "runner-runtime", "local-ai-scratch");
     fs.mkdirSync(scriptDir, { recursive: true });
     const scriptPath = path.join(scriptDir, "emit-artifact.js");

package/package.json

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