metheus-governance-mcp-cli 0.2.230 → 0.2.231

package/cli.mjs

@@ -2430,12 +2430,32 @@ function normalizeBotRunnerRequests(rawRequests, nowMs = Date.now()) {
       next_expected_responders: ensureArray(entry.next_expected_responders || entry.nextExpectedResponders)
         .map((value) => normalizeTelegramMentionUsername(value))
         .filter(Boolean),
+      normalized_execution_contract_type: String(entry.normalized_execution_contract_type || entry.normalizedExecutionContractType || "").trim().toLowerCase(),
+      normalized_execution_contract_targets: ensureArray(entry.normalized_execution_contract_targets || entry.normalizedExecutionContractTargets)
+        .map((value) => normalizeTelegramMentionUsername(value))
+        .filter(Boolean),
+      normalized_execution_next_responders: ensureArray(entry.normalized_execution_next_responders || entry.normalizedExecutionNextResponders)
+        .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(),
+      root_execution_contract_type: String(entry.root_execution_contract_type || entry.rootExecutionContractType || "").trim().toLowerCase(),
+      root_execution_contract_targets: ensureArray(entry.root_execution_contract_targets || entry.rootExecutionContractTargets)
+        .map((value) => normalizeTelegramMentionUsername(value))
+        .filter(Boolean),
+      root_next_expected_responders: ensureArray(entry.root_next_expected_responders || entry.rootNextExpectedResponders)
+        .map((value) => normalizeTelegramMentionUsername(value))
+        .filter(Boolean),
+      root_ai_reply_preview: String(entry.root_ai_reply_preview || entry.rootAiReplyPreview || "").trim(),
+      root_response_contract_validation_status: String(entry.root_response_contract_validation_status || entry.rootResponseContractValidationStatus || "").trim().toLowerCase(),
+      root_response_contract_validation_reason: String(entry.root_response_contract_validation_reason || entry.rootResponseContractValidationReason || "").trim(),
+      root_response_contract_validation_targets: ensureArray(entry.root_response_contract_validation_targets || entry.rootResponseContractValidationTargets)
+        .map((value) => normalizeTelegramMentionUsername(value))
+        .filter(Boolean),
       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)
@@ -4597,6 +4617,9 @@ function markRunnerRequestLifecycle({
   aiReplyGenerated = false,
   aiReplyGeneratedAt = "",
   aiReplyPreview = "",
+  normalizedExecutionContractType = "",
+  normalizedExecutionContractTargets = [],
+  normalizedExecutionNextResponders = [],
   responseContractValidationStatus = "",
   responseContractValidationReason = "",
   responseContractValidationTargets = [],
@@ -4668,6 +4691,8 @@ function markRunnerRequestLifecycle({
     return normalizeRunnerRequestStatus(existing.status);
   })();
   const nowISO = new Date().toISOString();
+  const commentKind = String(parsed.kind || "").trim().toLowerCase();
+  const isRootHumanComment = ["telegram_message", "telegram_edited_message"].includes(commentKind);
   const patch = {
     conversation_id: conversationID,
     conversation_participants: uniqueOrderedStrings(
@@ -4713,11 +4738,70 @@ function markRunnerRequestLifecycle({
       ensureArray(nextExpectedResponders).length ? nextExpectedResponders : existing.next_expected_responders,
       normalizeTelegramMentionUsername,
     ),
+    normalized_execution_contract_type: String(
+      normalizedExecutionContractType || existing.normalized_execution_contract_type || "",
+    ).trim().toLowerCase(),
+    normalized_execution_contract_targets: uniqueOrderedStrings(
+      ensureArray(normalizedExecutionContractTargets).length
+        ? normalizedExecutionContractTargets
+        : existing.normalized_execution_contract_targets,
+      normalizeTelegramMentionUsername,
+    ),
+    normalized_execution_next_responders: uniqueOrderedStrings(
+      ensureArray(normalizedExecutionNextResponders).length
+        ? normalizedExecutionNextResponders
+        : existing.normalized_execution_next_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(),
+    root_execution_contract_type: String(
+      isRootHumanComment
+        ? nextExecutionContractType
+        : existing.root_execution_contract_type || existing.execution_contract_type || "",
+    ).trim().toLowerCase(),
+    root_execution_contract_targets: uniqueOrderedStrings(
+      isRootHumanComment && ensureArray(executionContractTargets).length
+        ? executionContractTargets
+        : ensureArray(existing.root_execution_contract_targets).length
+          ? existing.root_execution_contract_targets
+          : existing.execution_contract_targets,
+      normalizeTelegramMentionUsername,
+    ),
+    root_next_expected_responders: uniqueOrderedStrings(
+      isRootHumanComment && ensureArray(nextExpectedResponders).length
+        ? nextExpectedResponders
+        : ensureArray(existing.root_next_expected_responders).length
+          ? existing.root_next_expected_responders
+          : existing.next_expected_responders,
+      normalizeTelegramMentionUsername,
+    ),
+    root_ai_reply_preview: String(
+      isRootHumanComment
+        ? aiReplyPreview || existing.root_ai_reply_preview || existing.ai_reply_preview || ""
+        : existing.root_ai_reply_preview || existing.ai_reply_preview || "",
+    ).trim(),
+    root_response_contract_validation_status: String(
+      isRootHumanComment
+        ? responseContractValidationStatus || existing.root_response_contract_validation_status || existing.response_contract_validation_status || ""
+        : existing.root_response_contract_validation_status || existing.response_contract_validation_status || "",
+    ).trim().toLowerCase(),
+    root_response_contract_validation_reason: String(
+      isRootHumanComment
+        ? responseContractValidationReason || existing.root_response_contract_validation_reason || existing.response_contract_validation_reason || ""
+        : existing.root_response_contract_validation_reason || existing.response_contract_validation_reason || "",
+    ).trim(),
+    root_response_contract_validation_targets: uniqueOrderedStrings(
+      isRootHumanComment && ensureArray(responseContractValidationTargets).length
+        ? responseContractValidationTargets
+        : ensureArray(existing.root_response_contract_validation_targets).length
+          ? existing.root_response_contract_validation_targets
+          : existing.response_contract_validation_targets,
+      normalizeTelegramMentionUsername,
+    ),
     response_contract_validation_status: String(
       responseContractValidationStatus || existing.response_contract_validation_status || "",
     ).trim().toLowerCase(),
@@ -8967,6 +9051,9 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
           executionContractActionable: processed.result?.execution_contract_actionable === true,
           executionContractTargets: ensureArray(processed.result?.execution_contract_targets),
           nextExpectedResponders: ensureArray(processed.result?.next_expected_responders),
+          normalizedExecutionContractType: String(processed.result?.normalized_execution_contract_type || "").trim(),
+          normalizedExecutionContractTargets: ensureArray(processed.result?.normalized_execution_contract_targets),
+          normalizedExecutionNextResponders: ensureArray(processed.result?.normalized_execution_next_responders),
           currentBotSelector,
           conversationIntentMode: String(processed.result?.conversation_intent_mode || "").trim(),
           normalizedIntent: resolvedIntentType,
@@ -11388,6 +11475,9 @@ async function runRunnerStartResolvedRoutes(routes, flags, options = {}) {
                         executionContractActionable: processed.result?.execution_contract_actionable === true,
                         executionContractTargets: ensureArray(processed.result?.execution_contract_targets),
                         nextExpectedResponders: ensureArray(processed.result?.next_expected_responders),
+                        normalizedExecutionContractType: String(processed.result?.normalized_execution_contract_type || "").trim(),
+                        normalizedExecutionContractTargets: ensureArray(processed.result?.normalized_execution_contract_targets),
+                        normalizedExecutionNextResponders: ensureArray(processed.result?.normalized_execution_next_responders),
                         currentBotSelector: normalizeTelegramMentionUsername(
                           deferredExecution.bot?.username || deferredExecution.bot?.name,
                         ),

package/lib/runner-orchestration.mjs

@@ -2502,8 +2502,8 @@ function buildWorkerFallbackExecutionPlan(plan, audit, options = {}) {
     .map((item) => safeObject(item))
     .filter((item) => String(item.role || "").trim());
   const hasWorker = executionPlanIncludesWorkerStep(normalizedPlan);
-  const requiresCtxpackUpdate = normalizedAudit.requires_ctxpack_update_step === true
-    || humanIntentType === "ctxpack_mutation";
+  const requiresCtxpackUpdate = safeObject(options).forceCtxpackUpdate === true
+    || normalizedAudit.requires_ctxpack_update_step === true;
   const requiresWorkItems = normalizedAudit.requires_work_items_step === true;
   if (hasWorker) {
     const patchedSteps = existingSteps.map((item) => {
@@ -2581,16 +2581,17 @@ function describeExecutionPlanAdequacyFailure(plan, audit) {
 function shouldForceWorkerFallbackExecutionPlan(plan, audit) {
   const normalizedPlan = safeObject(plan);
   const normalizedAudit = safeObject(audit);
-  if (executionPlanIncludesWorkerStep(normalizedPlan)) {
-    return false;
+  if (normalizedAudit.requires_ctxpack_update_step === true && !executionPlanIncludesCtxpackUpdateStep(normalizedPlan)) {
+    return true;
   }
-  if (normalizedAudit.requires_worker_step === true) {
+  if (normalizedAudit.requires_work_items_step === true && !executionPlanIncludesWorkItemsStep(normalizedPlan)) {
     return true;
   }
-  if (normalizedAudit.requires_ctxpack_update_step === true || normalizedAudit.requires_work_items_step === true) {
+  if (normalizedAudit.requires_worker_step === true && !executionPlanIncludesWorkerStep(normalizedPlan)) {
     return true;
   }
   return normalizedAudit.requires_execution === true
+    && !executionPlanIncludesWorkerStep(normalizedPlan)
     && normalizedAudit.plan_satisfies_request === false;
 }
 
@@ -2840,6 +2841,9 @@ async function maybeExecuteDynamicRolePlan({
   };
   let executedPlan;
   let executedPlanAudit = null;
+  const sourceMessageText = String(safeObject(selectedRecord?.parsedArchive).body || "").trim();
+  const explicitCtxpackRequest = looksLikeCtxpackGuidanceMutationRequest(sourceMessageText)
+    || /\bctxpack\b/i.test(sourceMessageText);
   try {
     executedPlan = await invokePlanner();
   } catch {
@@ -2890,8 +2894,9 @@ async function maybeExecuteDynamicRolePlan({
   let forcedWorkerFallback = false;
   if (adequacyFailure && shouldForceWorkerFallbackExecutionPlan(executedPlan, executedPlanAudit)) {
     executedPlan = buildWorkerFallbackExecutionPlan(executedPlan, executedPlanAudit, {
-      messageText: String(safeObject(selectedRecord?.parsedArchive).body || "").trim(),
+      messageText: sourceMessageText,
       humanIntentType,
+      forceCtxpackUpdate: explicitCtxpackRequest || safeObject(executedPlanAudit).requires_ctxpack_update_step === true,
     });
     executedPlanAudit = await auditPlannedExecution(executedPlan);
     adequacyFailure = describeExecutionPlanAdequacyFailure(executedPlan, executedPlanAudit);
@@ -2905,10 +2910,9 @@ async function maybeExecuteDynamicRolePlan({
   ) {
     adequacyFailure = "";
   }
-  const sourceMessageText = String(safeObject(selectedRecord?.parsedArchive).body || "").trim();
   if (
     (
-      humanIntentType === "ctxpack_mutation"
+      explicitCtxpackRequest
       || safeObject(executedPlanAudit).requires_ctxpack_update_step === true
     )
     && (
@@ -2923,7 +2927,11 @@ async function maybeExecuteDynamicRolePlan({
         requiresExecution: true,
       },
       executedPlanAudit,
-      { messageText: sourceMessageText, humanIntentType },
+      {
+        messageText: sourceMessageText,
+        humanIntentType,
+        forceCtxpackUpdate: true,
+      },
     );
     executedPlanAudit = await auditPlannedExecution(executedPlan);
     adequacyFailure = describeExecutionPlanAdequacyFailure(executedPlan, executedPlanAudit);
@@ -5421,6 +5429,12 @@ export async function processRunnerSelectedRecord({
     triggerDecision: effectiveTriggerDecision,
     conversationContext: effectiveConversationContext,
   });
+  const normalizedExecutionTargets = ensureArray(executionContract?.assignments)
+    .map((item) => normalizeMentionSelector(item?.targetBot))
+    .filter(Boolean);
+  const normalizedExecutionNextResponders = collectExecutionContractNextResponders(executionContract)
+    .map((item) => normalizeMentionSelector(item))
+    .filter(Boolean);
   const visibleDelegationTargets = uniqueOrdered(
     effectiveConversationContext?.mode === "public_multi_bot"
     && String(effectiveConversationContext?.stage || "").trim() === "human_opening"
@@ -5428,9 +5442,7 @@ export async function processRunnerSelectedRecord({
     && currentBotSelector
     && currentBotSelector === normalizeMentionSelector(effectiveConversationContext?.leadBotUsername)
     && normalizedExecutionContractType === "delegation"
-      ? ensureArray(executionContract?.assignments)
-        .map((item) => normalizeMentionSelector(item?.targetBot))
-        .filter(Boolean)
+      ? normalizedExecutionTargets
       : [],
   );
   if (responseContractValidation.ok && visibleDelegationTargets.length > 0) {
@@ -5457,14 +5469,22 @@ export async function processRunnerSelectedRecord({
     && currentBotSelector !== normalizeMentionSelector(effectiveConversationContext.leadBotUsername)
     && normalizedExecutionContractType === "delegation"
   ) {
-    const unauthorizedDelegationTargets = uniqueOrdered([
-      ...ensureArray(executionContract?.assignments)
-        .map((item) => normalizeMentionSelector(item?.targetBot))
-        .filter(Boolean),
-      ...collectExecutionContractNextResponders(executionContract)
+    const currentContractScopeTargets = uniqueOrdered([
+      ...collectExecutionContractNextResponders(safeObject(effectiveConversationContext.executionContract))
         .map((item) => normalizeMentionSelector(item))
         .filter(Boolean),
-    ]).filter((item) => item && item !== currentBotSelector);
+      normalizeMentionSelector(
+        safeObject(effectiveConversationContext.executionContract).summaryBot
+        || safeObject(effectiveConversationContext.executionContract).summary_bot
+        || effectiveConversationContext.summaryBotUsername,
+      ),
+      normalizeMentionSelector(effectiveConversationContext.leadBotUsername),
+      normalizeMentionSelector(effectiveConversationContext.summaryBotUsername),
+    ].filter(Boolean));
+    const unauthorizedDelegationTargets = uniqueOrdered([
+      ...normalizedExecutionTargets,
+      ...normalizedExecutionNextResponders,
+    ]).filter((item) => item && item !== currentBotSelector && !currentContractScopeTargets.includes(item));
     if (unauthorizedDelegationTargets.length > 0) {
       responseContractValidation = {
         ok: false,
@@ -5474,55 +5494,6 @@ export async function processRunnerSelectedRecord({
       };
     }
   }
-  if (!responseContractValidation.ok && String(responseContractValidation.status || "").trim() === "non_lead_public_assignment") {
-    const reason = String(responseContractValidation.reason || "").trim()
-      || "response contract validation failed";
-    saveRunnerRouteState(
-      routeKey,
-      buildRunnerRouteStateFromComment(selectedRecord, {
-        last_action: "conversation_skipped",
-        last_reason: reason,
-        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: reason,
-        last_contract_validation_targets: ensureArray(responseContractValidation.targets),
-        ...intentStatePatch,
-      }),
-    );
-    return {
-      kind: "skipped",
-      skippedRecord: {
-        id: selectedRecord.id,
-        reason,
-        messageID: intFromRawAllowZero(selectedRecord?.parsedArchive?.messageID, 0),
-      },
-      result: {
-        route_key: routeKey,
-        route_name: normalizedRoute.name,
-        outcome: "contract_validation_failed",
-        detail: reason,
-        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(),
-        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),
-        response_contract_validation_status: String(responseContractValidation.status || "").trim(),
-        response_contract_validation_reason: reason,
-        response_contract_validation_targets: ensureArray(responseContractValidation.targets),
-        assignment_validation_status: String(assignmentExecutionValidation.status || "").trim(),
-        assignment_validation_reason: String(assignmentExecutionValidation.reason || "").trim(),
-        assignment_validation_modes: ensureArray(assignmentExecutionValidation.assignmentModes),
-      },
-    };
-  }
   if (effectiveConversationContext?.mode === "public_multi_bot") {
     const currentBotSelector = normalizeMentionSelector(bot?.username || bot?.name);
     const currentSession = safeObject(effectiveConversationContext.session);
@@ -5679,6 +5650,9 @@ export async function processRunnerSelectedRecord({
         execution_contract_actionable: executionContract?.actionable === true,
         execution_contract_targets: ensureArray(executionContract?.assignments).map((item) => normalizeMentionSelector(item.targetBot)).filter(Boolean),
         next_expected_responders: collectExecutionContractNextResponders(executionContract),
+        normalized_execution_contract_type: normalizedExecutionContractType,
+        normalized_execution_contract_targets: normalizedExecutionTargets,
+        normalized_execution_next_responders: normalizedExecutionNextResponders,
         artifact_validation: String(artifactValidation.status || "").trim() || "none",
         artifact_paths: summarizeValidatedArtifactPaths(artifactValidation),
         ai_reply_generated: true,
@@ -5755,15 +5729,15 @@ export async function processRunnerSelectedRecord({
           participants: ensureArray(effectiveConversationContext.participantSelectors),
           initial_responders: ensureArray(effectiveConversationContext.initialResponderSelectors),
           allowed_responders: ensureArray(effectiveConversationContext.allowedResponderSelectors),
-          last_execution_contract_type: String(executionContract?.type || "").trim(),
-          last_execution_contract_actionable: executionContract?.actionable === true,
-          last_execution_contract_targets: ensureArray(executionContract?.assignments).map((item) => normalizeMentionSelector(item.targetBot)).filter(Boolean),
-          next_expected_responders: collectExecutionContractNextResponders(executionContract),
-          last_speaker_bot_username: currentBotSelector,
-          speaker_counts: speakerCounts,
-          last_sender_bot_username: String(effectiveConversationContext?.senderBotUsername || "").trim(),
-          last_reply_fingerprint_by_bot: {
-            ...safeObject(currentSession.last_reply_fingerprint_by_bot),
+            last_execution_contract_type: String(executionContract?.type || "").trim(),
+            last_execution_contract_actionable: executionContract?.actionable === true,
+            last_execution_contract_targets: normalizedExecutionTargets,
+            next_expected_responders: normalizedExecutionNextResponders,
+            last_speaker_bot_username: currentBotSelector,
+            speaker_counts: speakerCounts,
+            last_sender_bot_username: String(effectiveConversationContext?.senderBotUsername || "").trim(),
+            last_reply_fingerprint_by_bot: {
+              ...safeObject(currentSession.last_reply_fingerprint_by_bot),
             [currentBotSelector]: normalizeConversationReplyFingerprint(sanitizedReplyText),
           },
         },
@@ -5781,14 +5755,17 @@ export async function processRunnerSelectedRecord({
           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_assignment_validation_status: String(assignmentExecutionValidation.status || "").trim(),
-        last_assignment_validation_reason: String(assignmentExecutionValidation.reason || "").trim(),
-        last_trigger: String(effectiveTriggerDecision.trigger || "").trim(),
-        last_reason: effectiveConversationContext?.mode === "public_multi_bot"
-          ? [
+          last_contract_validation_status: String(responseContractValidation.status || "").trim(),
+          last_contract_validation_reason: String(responseContractValidation.reason || "").trim(),
+          last_contract_validation_targets: ensureArray(responseContractValidation.targets),
+          last_normalized_execution_contract_type: normalizedExecutionContractType,
+          last_normalized_execution_contract_targets: normalizedExecutionTargets,
+          last_normalized_execution_next_responders: normalizedExecutionNextResponders,
+          last_assignment_validation_status: String(assignmentExecutionValidation.status || "").trim(),
+          last_assignment_validation_reason: String(assignmentExecutionValidation.reason || "").trim(),
+          last_trigger: String(effectiveTriggerDecision.trigger || "").trim(),
+          last_reason: effectiveConversationContext?.mode === "public_multi_bot"
+            ? [
             `conversation=${String(effectiveConversationContext.id || "").trim() || "-"}`,
             `stage=${String(effectiveConversationContext.stage || "").trim() || "-"}`,
             formatConversationContractSummary(effectiveConversationContext),
@@ -5855,13 +5832,16 @@ export async function processRunnerSelectedRecord({
       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),
+        conversation_reply_expectation: String(effectiveConversationContext?.replyExpectation || "").trim(),
+        execution_contract_type: String(executionContract?.type || "").trim(),
+        execution_contract_actionable: executionContract?.actionable === true,
+        execution_contract_targets: normalizedExecutionTargets,
+        next_expected_responders: normalizedExecutionNextResponders,
+        normalized_execution_contract_type: normalizedExecutionContractType,
+        normalized_execution_contract_targets: normalizedExecutionTargets,
+        normalized_execution_next_responders: normalizedExecutionNextResponders,
+        artifact_validation: String(artifactValidation.status || "").trim() || "none",
+        artifact_paths: summarizeValidatedArtifactPaths(artifactValidation),
       ctxpack_version_id: String(safeObject(aiResult?.ctxpackUpdate).version_id || "").trim(),
       ctxpack_changed_paths: ensureArray(safeObject(aiResult?.ctxpackUpdate).changed_paths).map((item) => String(item || "").trim()).filter(Boolean),
       ctxpack_pushed_file_count: intFromRawAllowZero(safeObject(aiResult?.ctxpackUpdate).pushed_file_count, 0),

package/lib/selftest-runner-scenarios.mjs

@@ -9644,16 +9644,168 @@ export async function runSelftestRunnerScenarios(push, deps) {
         && 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)")}`,
     );
-  } catch (err) {
-    push("delegated_single_lead_non_lead_summary_request_allowed", false, String(err?.message || err));
-  }
+    } catch (err) {
+      push("delegated_single_lead_non_lead_summary_request_allowed", false, String(err?.message || err));
+    }
 
-  try {
-    let aiCalls = 0;
-    const processed = await processRunnerSelectedRecord({
-      routeKey: "delegated-single-lead-non-lead-new-assignment-blocked-key",
-      normalizedRoute: normalizeRunnerRoute({
-        name: "telegram-monitor-delegated-single-lead-non-lead-new-assignment-blocked",
+    try {
+      let aiCalls = 0;
+      const processed = await processRunnerSelectedRecord({
+        routeKey: "delegated-single-lead-non-lead-handoff-back-to-lead-key",
+        normalizedRoute: normalizeRunnerRoute({
+          name: "telegram-monitor-delegated-single-lead-non-lead-handoff-back-to-lead",
+          project_id: selftestProjectID,
+          provider: "telegram",
+          role: "monitor",
+          role_profile: "monitor",
+          destination_id: "dest-1",
+          destination_label: "Main Room",
+          server_bot_name: "RyoAI2_bot",
+          server_bot_id: "bot-peer-1",
+          trigger_policy: {
+            mentions_only: true,
+            direct_messages: true,
+            reply_to_bot_messages: true,
+          },
+        }),
+        routeState: {
+          conversation_sessions: {
+            "delegated-single-lead-non-lead-handoff-back-to-lead": {
+              id: "delegated-single-lead-non-lead-handoff-back-to-lead",
+              mode: "public_multi_bot",
+              stage: "bot_reply",
+              status: "open",
+              intent_mode: "delegated_single_lead",
+              lead_bot_username: "ryoai_bot",
+              participants: ["ryoai_bot", "ryoai2_bot", "ryoai3_bot"],
+              initial_responders: ["ryoai_bot"],
+              allowed_responders: ["ryoai_bot", "ryoai2_bot", "ryoai3_bot"],
+              next_expected_responders: ["ryoai2_bot"],
+              last_execution_contract_type: "delegation",
+              last_execution_contract_targets: ["ryoai2_bot"],
+              last_execution_contract_actionable: true,
+            },
+          },
+        },
+        selectedRecord: {
+          id: "delegated-single-lead-non-lead-handoff-back-to-lead-comment",
+          body: "@RyoAI2_bot 현재 관점으로 의견 주세요.",
+          threadID: "thread-1",
+          createdAt: "2026-03-24T00:00:00.000Z",
+          updatedAt: "2026-03-24T00:00:00.000Z",
+          parsedArchive: {
+            kind: "bot_reply",
+            body: "@RyoAI2_bot 현재 관점으로 의견 주세요.",
+            senderIsBot: true,
+            botUsername: "ryoai_bot",
+            botName: "RyoAI_bot",
+            sender: "RyoAI_bot",
+            senderName: "RyoAI_bot",
+            senderBotUsername: "ryoai_bot",
+            messageID: 990212,
+            chatID: "-1001",
+            mentionUsernames: ["ryoai2_bot"],
+            conversationID: "delegated-single-lead-non-lead-handoff-back-to-lead",
+            executionContract: {
+              type: "delegation",
+              actionable: true,
+              assignments: [{ targetBot: "ryoai2_bot", task: "현재 관점으로 의견을 말하고 리드에게 정리 요청" }],
+              nextResponders: ["ryoai2_bot"],
+            },
+          },
+        },
+        pendingOrdered: [],
+        bot: { id: "bot-peer-1", username: "ryoai2_bot", name: "RyoAI2_bot" },
+        destination: { id: "dest-1", provider: "telegram", chatID: "-1001", label: "Main Room" },
+        archiveThread: {
+          threadID: "thread-1",
+          source: "telegram",
+          projectID: selftestProjectID,
+        },
+        executionPlan: {
+          mode: "role_profile",
+          roleProfileName: "monitor",
+          roleProfile: {
+            client: "sample",
+            model: "",
+            permissionMode: "read_only",
+            reasoningEffort: "low",
+          },
+          workspaceDir: path.join(os.tmpdir(), "metheus-runner-selftest-non-lead-handoff-back-to-lead"),
+          workspaceSource: "selftest",
+          usedCommandFallback: false,
+        },
+        runtime: {
+          baseURL: "https://example.test",
+          token: "selftest-token",
+          timeoutSeconds: 30,
+          actor: { user_id: "user-1" },
+        },
+        triggerDecision: {
+          trigger: "bot_reply_mention",
+          requiresDirectReply: true,
+          candidateResponder: true,
+        },
+        responderAdjudication: {
+          decision: "reply",
+          selected_bot_usernames: ["ryoai2_bot"],
+        },
+        deps: {
+          saveRunnerRouteState: () => {},
+          startRunnerTypingHeartbeat: () => ({ async stop() {} }),
+          runRunnerAIExecution: async () => {
+            aiCalls += 1;
+            return {
+              reply: "@RyoAI_bot 현재 공개된 맥락 기준으로 우선순위와 리스크를 먼저 정리했습니다. 다음 정리를 부탁드립니다.",
+              artifacts: [],
+              ctxpackFiles: [],
+              workItems: [],
+              contract: {
+                type: "delegation",
+                actionable: true,
+                assignments: [{ target_bot: "ryoai_bot", task: "현재 contributor 의견을 정리해서 다음 단계 제안" }],
+                next_responders: ["ryoai_bot"],
+              },
+            };
+          },
+          managedConversationBots: [
+            { id: "bot-lead", name: "RyoAI_bot" },
+            { id: "bot-peer-1", name: "RyoAI2_bot" },
+            { id: "bot-peer-2", name: "RyoAI3_bot" },
+          ],
+          performLocalBotDelivery: async () => ({
+            delivery: { dryRun: true, body: {} },
+            archive: {},
+          }),
+          serializeRunnerTriggerPolicy: (value) => value,
+          serializeRunnerArchivePolicy: (value) => value,
+          buildRunnerExecutionDeps: () => ({}),
+          buildRunnerDeliveryDeps: () => ({}),
+          buildRunnerRuntimeDeps: () => ({}),
+          resolveConversationPeerBots: () => [
+            { id: "bot-lead", name: "RyoAI_bot" },
+            { id: "bot-peer-1", name: "RyoAI2_bot" },
+            { id: "bot-peer-2", name: "RyoAI3_bot" },
+          ],
+        },
+      });
+      push(
+        "delegated_single_lead_non_lead_handoff_back_to_lead_not_blocked",
+        processed.kind === "replied"
+          && aiCalls === 1
+          && String(processed.result?.response_contract_validation_status || "") !== "non_lead_public_assignment",
+        `kind=${String(processed.kind || "(none)")} ai_calls=${aiCalls} validation=${String(processed.result?.response_contract_validation_status || "(none)")} contract=${String(processed.result?.execution_contract_type || "(none)")} reason=${String(processed.skippedRecord?.reason || "(none)")}`,
+      );
+    } catch (err) {
+      push("delegated_single_lead_non_lead_handoff_back_to_lead_not_blocked", false, String(err?.message || err));
+    }
+
+    try {
+      let aiCalls = 0;
+      const processed = await processRunnerSelectedRecord({
+        routeKey: "delegated-single-lead-non-lead-new-assignment-recorded-key",
+        normalizedRoute: normalizeRunnerRoute({
+          name: "telegram-monitor-delegated-single-lead-non-lead-new-assignment-recorded",
         project_id: selftestProjectID,
         provider: "telegram",
         role: "monitor",
@@ -9777,16 +9929,16 @@ export async function runSelftestRunnerScenarios(push, deps) {
         ],
       },
     });
-    push(
-      "delegated_single_lead_non_lead_new_assignment_blocked",
-      processed.kind === "skipped"
-        && aiCalls === 1
-        && String(processed.result?.response_contract_validation_status || "") === "non_lead_public_assignment",
-      `kind=${String(processed.kind || "(none)")} ai_calls=${aiCalls} validation=${String(processed.result?.response_contract_validation_status || "(none)")} reason=${String(processed.skippedRecord?.reason || "(none)")}`,
-    );
-  } catch (err) {
-    push("delegated_single_lead_non_lead_new_assignment_blocked", false, String(err?.message || err));
-  }
+      push(
+        "delegated_single_lead_non_lead_new_assignment_recorded",
+        processed.kind === "replied"
+          && aiCalls === 1
+          && String(processed.result?.response_contract_validation_status || "") === "non_lead_public_assignment",
+        `kind=${String(processed.kind || "(none)")} ai_calls=${aiCalls} validation=${String(processed.result?.response_contract_validation_status || "(none)")} reason=${String(processed.result?.response_contract_validation_reason || "(none)")}`,
+      );
+    } catch (err) {
+      push("delegated_single_lead_non_lead_new_assignment_recorded", false, String(err?.message || err));
+    }
 
   try {
     const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), "metheus-runner-selftest-artifacts-ok-"));

package/package.json

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