metheus-governance-mcp-cli 0.2.225 → 0.2.227

package/cli.mjs

@@ -2073,13 +2073,38 @@ function writeTextFileAtomic(filePath, text) {
     `.${path.basename(normalizedPath)}.${process.pid}.${Date.now()}.tmp`,
   );
   fs.writeFileSync(tempPath, text, "utf8");
+  const renameRetryDelaysMs = [0, 20, 50, 100, 200];
+  const sleepBuffer = new SharedArrayBuffer(4);
+  const sleepArray = new Int32Array(sleepBuffer);
+  let lastRenameError = null;
   try {
-    fs.renameSync(tempPath, normalizedPath);
-  } catch (error) {
-    try {
-      fs.rmSync(normalizedPath, { force: true });
-    } catch {}
-    fs.renameSync(tempPath, normalizedPath);
+    for (const delayMs of renameRetryDelaysMs) {
+      if (delayMs > 0) {
+        Atomics.wait(sleepArray, 0, 0, delayMs);
+      }
+      try {
+        fs.renameSync(tempPath, normalizedPath);
+        lastRenameError = null;
+        break;
+      } catch (error) {
+        lastRenameError = error;
+        try {
+          fs.rmSync(normalizedPath, { force: true });
+          fs.renameSync(tempPath, normalizedPath);
+          lastRenameError = null;
+          break;
+        } catch (retryError) {
+          lastRenameError = retryError;
+          const errorCode = String(retryError?.code || error?.code || "").trim().toUpperCase();
+          if (!["EPERM", "EBUSY", "ENOTEMPTY"].includes(errorCode)) {
+            throw retryError;
+          }
+        }
+      }
+    }
+    if (lastRenameError) {
+      throw lastRenameError;
+    }
   } finally {
     try {
       if (fs.existsSync(tempPath)) {
@@ -2397,6 +2422,11 @@ function normalizeBotRunnerRequests(rawRequests, nowMs = Date.now()) {
       response_contract_validation_targets: ensureArray(entry.response_contract_validation_targets || entry.responseContractValidationTargets)
         .map((value) => normalizeTelegramMentionUsername(value))
         .filter(Boolean),
+      assignment_validation_status: String(entry.assignment_validation_status || entry.assignmentValidationStatus || "").trim().toLowerCase(),
+      assignment_validation_reason: String(entry.assignment_validation_reason || entry.assignmentValidationReason || "").trim(),
+      assignment_validation_modes: ensureArray(entry.assignment_validation_modes || entry.assignmentValidationModes)
+        .map((value) => String(value || "").trim().toLowerCase())
+        .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(),
@@ -2427,15 +2457,17 @@ function normalizeBotRunnerRequests(rawRequests, nowMs = Date.now()) {
 function normalizeBotRunnerConsumedComments(rawConsumed, nowMs = Date.now()) {
   const normalized = {};
   for (const [commentIDRaw, entryRaw] of Object.entries(safeObject(rawConsumed))) {
-    const commentID = String(commentIDRaw || safeObject(entryRaw).comment_id || "").trim();
-    if (!commentID) continue;
     const entry = safeObject(entryRaw);
+    const commentID = String(entry.comment_id || commentIDRaw || "").trim();
+    if (!commentID) continue;
+    const ledgerKey = String(commentIDRaw || commentID).trim();
     const consumedAt = firstNonEmptyString([entry.consumed_at, entry.consumedAt, entry.updated_at, entry.updatedAt]);
     const consumedAtMs = Date.parse(consumedAt);
     if (Number.isFinite(consumedAtMs) && nowMs - consumedAtMs > BOT_RUNNER_REQUEST_KEEP_MS) {
       continue;
     }
-    normalized[commentID] = {
+    normalized[ledgerKey] = {
+      ledger_key: ledgerKey,
       comment_id: commentID,
       project_id: String(entry.project_id || entry.projectID || "").trim(),
       provider: String(entry.provider || "").trim(),
@@ -2451,6 +2483,38 @@ function normalizeBotRunnerConsumedComments(rawConsumed, nowMs = Date.now()) {
   return normalized;
 }
 
+function buildRunnerConsumedCommentLedgerKey(commentIDRaw, routeKeyRaw = "", commentKindRaw = "") {
+  const commentID = String(commentIDRaw || "").trim();
+  if (!commentID) return "";
+  const routeKey = String(routeKeyRaw || "").trim();
+  const commentKind = String(commentKindRaw || "").trim().toLowerCase();
+  if (commentKind === "bot_reply" && routeKey) {
+    return `${commentID}::${routeKey}`;
+  }
+  return commentID;
+}
+
+function findRunnerConsumedCommentEntry(rawConsumed, commentIDRaw, { routeKey = "", commentKind = "" } = {}) {
+  const commentID = String(commentIDRaw || "").trim();
+  if (!commentID) return {};
+  const consumedComments = normalizeBotRunnerConsumedComments(rawConsumed);
+  const ledgerKey = buildRunnerConsumedCommentLedgerKey(commentID, routeKey, commentKind);
+  const directEntry = safeObject(consumedComments[ledgerKey]);
+  if (Object.keys(directEntry).length) {
+    return directEntry;
+  }
+  const normalizedKind = String(commentKind || "").trim().toLowerCase();
+  if (normalizedKind === "bot_reply" && String(routeKey || "").trim()) {
+    const routeEntry = Object.values(consumedComments).find((entryRaw) => {
+      const entry = safeObject(entryRaw);
+      return String(entry.comment_id || "").trim() === commentID
+        && String(entry.route_key || "").trim() === String(routeKey || "").trim();
+    });
+    return safeObject(routeEntry);
+  }
+  return safeObject(consumedComments[commentID]);
+}
+
 function runnerRouteMatchesProjectConversationScope(candidateRouteRaw, normalizedRouteRaw) {
   const candidateRoute = normalizeRunnerRoute(candidateRouteRaw);
   const normalizedRoute = normalizeRunnerRoute(normalizedRouteRaw);
@@ -3320,7 +3384,8 @@ function upsertRunnerConsumedComment(state, commentIDRaw, patch = {}) {
   const commentID = String(commentIDRaw || "").trim();
   const currentState = safeObject(state);
   const consumedComments = normalizeBotRunnerConsumedComments(currentState.consumedComments || currentState.consumed_comments);
-  const existing = safeObject(consumedComments[commentID]);
+  const ledgerKey = buildRunnerConsumedCommentLedgerKey(commentID, patch.route_key, patch.comment_kind);
+  const existing = safeObject(consumedComments[ledgerKey]);
   const nextEntry = {
     ...existing,
     ...safeObject(patch),
@@ -3330,7 +3395,7 @@ function upsertRunnerConsumedComment(state, commentIDRaw, patch = {}) {
     consumed_at: new Date().toISOString(),
     request_status: normalizeRunnerRequestStatus(patch.request_status || existing.request_status),
   };
-  consumedComments[commentID] = nextEntry;
+  consumedComments[ledgerKey] = nextEntry;
   return {
     consumedComments,
     consumedComment: nextEntry,
@@ -4516,6 +4581,9 @@ function markRunnerRequestLifecycle({
   responseContractValidationStatus = "",
   responseContractValidationReason = "",
   responseContractValidationTargets = [],
+  assignmentValidationStatus = "",
+  assignmentValidationReason = "",
+  assignmentValidationModes = [],
   deliveryStatus = "",
   archiveStatus = "",
   transportError = "",
@@ -4643,6 +4711,18 @@ function markRunnerRequestLifecycle({
         : existing.response_contract_validation_targets,
       normalizeTelegramMentionUsername,
     ),
+    assignment_validation_status: String(
+      assignmentValidationStatus || existing.assignment_validation_status || "",
+    ).trim().toLowerCase(),
+    assignment_validation_reason: String(
+      assignmentValidationReason || existing.assignment_validation_reason || "",
+    ).trim(),
+    assignment_validation_modes: uniqueOrderedStrings(
+      ensureArray(assignmentValidationModes).length
+        ? assignmentValidationModes
+        : existing.assignment_validation_modes,
+      (value) => String(value || "").trim().toLowerCase(),
+    ),
     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(),
@@ -8074,14 +8154,18 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
     const commentsForPending = ensureArray(comments).filter((comment) => {
       const normalizedComment = normalizeArchiveCommentRecord(comment, parseArchivedChatComment);
       const commentID = String(normalizedComment.id || "").trim();
+      const parsed = safeObject(normalizedComment.parsedArchive);
+      const commentKind = String(parsed.kind || "").trim().toLowerCase();
       if (commentID && safeObject(excludedComments)[commentID]) {
         return false;
       }
-      if (commentID && safeObject(consumedComments)[commentID]) {
+      if (commentID && Object.keys(findRunnerConsumedCommentEntry(consumedComments, commentID, {
+        routeKey,
+        commentKind,
+      })).length > 0) {
         return false;
       }
-      const parsed = safeObject(normalizedComment.parsedArchive);
-      if (String(parsed.kind || "").trim().toLowerCase() === "bot_reply") {
+      if (commentKind === "bot_reply") {
         const conversationID = String(parsed.conversationID || "").trim();
         if (!conversationID) {
           return false;
@@ -8873,6 +8957,9 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
           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),
+          assignmentValidationStatus: String(processed.result?.assignment_validation_status || "").trim(),
+          assignmentValidationReason: String(processed.result?.assignment_validation_reason || "").trim(),
+          assignmentValidationModes: ensureArray(processed.result?.assignment_validation_modes),
           deliveryStatus: String(processed.result?.delivery_status || "").trim(),
           archiveStatus: String(processed.result?.archive_status || "").trim(),
           transportError: String(processed.result?.transport_error || "").trim(),
@@ -11293,6 +11380,9 @@ async function runRunnerStartResolvedRoutes(routes, flags, options = {}) {
                         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),
+                        assignmentValidationStatus: String(processed.result?.assignment_validation_status || "").trim(),
+                        assignmentValidationReason: String(processed.result?.assignment_validation_reason || "").trim(),
+                        assignmentValidationModes: ensureArray(processed.result?.assignment_validation_modes),
                         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

@@ -1918,7 +1918,10 @@ export function buildLocalBotPrompt(payload, { terse = true } = {}) {
         "Do not mention another managed bot unless the contract explicitly names that bot in assignments or next_responders.",
         "Without a matching contract, newly mentioned bots will not act.",
         "When delegating to another managed bot, use contract.type=\"delegation\" with actionable=true, assignments, and next_responders.",
-        "Delegation contract example: {\"type\":\"delegation\",\"actionable\":true,\"assignments\":[{\"target_bot\":\"ryoai2_bot\",\"task\":\"briefly greet in one line\"}],\"next_responders\":[\"ryoai2_bot\"]}.",
+        "Each assignment must declare whether it is a conversational contribution or a real execution task.",
+        "Use assignment.mode=\"conversation_contribution\" for opinions, discussion, review, comparison, synthesis, greetings, or other room-visible contributions that do not require workspace artifacts.",
+        "Use assignment.mode=\"execution_task\" only when the delegated bot must change workspace files, create artifacts, update ctxpack, or produce other concrete project outputs. If it is an execution task, also set artifacts_required=true.",
+        "Delegation contract example: {\"type\":\"delegation\",\"actionable\":true,\"assignments\":[{\"target_bot\":\"ryoai2_bot\",\"task\":\"briefly greet in one line\",\"mode\":\"conversation_contribution\",\"artifacts_required\":false}],\"next_responders\":[\"ryoai2_bot\"]}.",
         ensureArray(responseContract.required_delegation_targets).length > 0
           ? `This reply must delegate to these exact managed bots now: ${ensureArray(responseContract.required_delegation_targets).map((item) => `@${String(item || "").trim().replace(/^@+/, "")}`).join(", ")}.`
           : "",
@@ -1970,7 +1973,10 @@ export function buildLocalBotPrompt(payload, { terse = true } = {}) {
         "Do not mention another managed bot unless the contract explicitly names that bot in assignments or next_responders.",
         "Without a matching contract, mentioned bots will not act.",
         "When delegating to another managed bot, use contract.type=\"delegation\" with actionable=true, assignments, and next_responders.",
-        "Delegation contract example: {\"type\":\"delegation\",\"actionable\":true,\"assignments\":[{\"target_bot\":\"ryoai2_bot\",\"task\":\"briefly greet in one line\"}],\"next_responders\":[\"ryoai2_bot\"]}.",
+        "Each assignment must declare whether it is a conversational contribution or a real execution task.",
+        "Use assignment.mode=\"conversation_contribution\" for opinions, discussion, review, comparison, synthesis, greetings, or other room-visible contributions that do not require workspace artifacts.",
+        "Use assignment.mode=\"execution_task\" only when the delegated bot must change workspace files, create artifacts, update ctxpack, or produce other concrete project outputs. If it is an execution task, also set artifacts_required=true.",
+        "Delegation contract example: {\"type\":\"delegation\",\"actionable\":true,\"assignments\":[{\"target_bot\":\"ryoai2_bot\",\"task\":\"briefly greet in one line\",\"mode\":\"conversation_contribution\",\"artifacts_required\":false}],\"next_responders\":[\"ryoai2_bot\"]}.",
         ensureArray(responseContract.required_delegation_targets).length > 0
           ? `This reply must delegate to these exact managed bots now: ${ensureArray(responseContract.required_delegation_targets).map((item) => `@${String(item || "").trim().replace(/^@+/, "")}`).join(", ")}.`
           : "",
@@ -2006,7 +2012,7 @@ export function buildLocalBotPrompt(payload, { terse = true } = {}) {
     isInternalExecutionStep
       ? "Return JSON only in one line: {\"reply\":\"what was completed in this step\",\"artifacts\":[{\"path\":\"relative/or/absolute/path\",\"kind\":\"plan|code|doc|spec|test\",\"operation\":\"create|update|delete\"}],\"ctxpack_files\":[{\"path\":\"relative/path.md\",\"content\":\"full document text\",\"doc_type\":\"guide|readme|agenda|rule|architecture|manifest\",\"operation\":\"create|update|delete\"}],\"work_items\":[{\"title\":\"short atomic task\",\"description\":\"useful implementation detail\"}],\"contract\":{\"type\":\"direct_result|summary_request|final_summary\",\"actionable\":true,\"summary_bot\":\"username\",\"next_responders\":[\"username\"]}}. Use ctxpack_files when ctxpack-backed guidance/instruction files must be authored. If execution_step.ctxpack_update_required is true, ctxpack_files must not be empty. Use artifacts: [] only if this step truly changes no project files, and use work_items: [] only if this step truly creates no governance tasks."
       : responseContract.is_current_bot_candidate === true
-      ? "Return JSON only in one line: {\"reply\":\"...\",\"artifacts\":[],\"ctxpack_files\":[],\"work_items\":[]} or {\"clarify\":\"...\"} or {\"skip\":true,\"reason\":\"...\"} or {\"reply\":\"...\",\"artifacts\":[],\"ctxpack_files\":[],\"work_items\":[],\"contract\":{\"type\":\"direct_result|delegation|summary_request|final_summary\",\"actionable\":true,\"assignments\":[{\"target_bot\":\"username\",\"task\":\"...\"}],\"summary_bot\":\"username\",\"next_responders\":[\"username\"]},\"context_suggestion\":{\"should_store\":true,\"title\":\"...\",\"body\":\"...\",\"category\":\"bot_role|operating_rule|project_fact|current_focus|risk|general\",\"importance\":\"low|normal|high|critical\"}}."
+      ? "Return JSON only in one line: {\"reply\":\"...\",\"artifacts\":[],\"ctxpack_files\":[],\"work_items\":[]} or {\"clarify\":\"...\"} or {\"skip\":true,\"reason\":\"...\"} or {\"reply\":\"...\",\"artifacts\":[],\"ctxpack_files\":[],\"work_items\":[],\"contract\":{\"type\":\"direct_result|delegation|summary_request|final_summary\",\"actionable\":true,\"assignments\":[{\"target_bot\":\"username\",\"task\":\"...\",\"mode\":\"conversation_contribution|execution_task\",\"artifacts_required\":true|false}],\"summary_bot\":\"username\",\"next_responders\":[\"username\"]},\"context_suggestion\":{\"should_store\":true,\"title\":\"...\",\"body\":\"...\",\"category\":\"bot_role|operating_rule|project_fact|current_focus|risk|general\",\"importance\":\"low|normal|high|critical\"}}."
       : terse
         ? "Return JSON only in one line: {\"reply\":\"...\",\"artifacts\":[],\"ctxpack_files\":[],\"work_items\":[],\"context_suggestion\":{\"should_store\":true,\"title\":\"...\",\"body\":\"...\",\"category\":\"bot_role|operating_rule|project_fact|current_focus|risk|general\",\"importance\":\"low|normal|high|critical\"}} or {\"clarify\":\"...\"} or {\"skip\":true,\"reason\":\"...\"}."
         : "Return JSON only: {\"reply\":\"...\",\"artifacts\":[],\"ctxpack_files\":[],\"work_items\":[],\"context_suggestion\":{\"should_store\":true,\"title\":\"...\",\"body\":\"...\",\"category\":\"bot_role|operating_rule|project_fact|current_focus|risk|general\",\"importance\":\"low|normal|high|critical\"}} or {\"clarify\":\"...\"} or {\"skip\":true,\"reason\":\"...\"}. Keep the reply concise and directly useful in a group chat.",
@@ -2061,7 +2067,12 @@ export function buildLocalBotPrompt(payload, { terse = true } = {}) {
       }
       if (assignmentsForThisBot.length > 0) {
         lines.push(
-          `Current Assignment For This Bot: ${assignmentsForThisBot.map((item) => String(item.task || "").trim()).join(" | ")}`,
+          `Current Assignment For This Bot: ${assignmentsForThisBot.map((item) => {
+            const task = String(item.task || "").trim();
+            const mode = String(item.mode || "").trim();
+            const artifactsRequired = item.artifactsRequired === true || item.artifacts_required === true;
+            return `${task}${mode ? ` [mode=${mode}]` : ""}${artifactsRequired ? " [artifacts_required=yes]" : ""}`;
+          }).join(" | ")}`,
         );
       }
       if (String(currentExecutionContract.summary_bot || currentExecutionContract.summaryBot || "").trim()) {
@@ -2149,11 +2160,13 @@ export function buildLocalBotPrompt(payload, { terse = true } = {}) {
             "A valid follow-up may be a concise opinion, analysis, review, comparison, synthesis, or direct delegated result.",
             "Mentioning the lead bot for acknowledgment or handoff does not require a new delegation contract.",
             "Do not wake any third bot. Only the lead bot may delegate new public work in this conversation.",
-            "If you complete your assigned contribution and the lead bot should continue or synthesize, use contract.type=\"summary_request\" with the designated summary bot.",
+            "If any other expected responder besides this bot still remains in the current execution contract, do not emit contract.type=\"summary_request\" yet.",
+            "Only the final remaining contributor may hand control back to the designated summary bot with contract.type=\"summary_request\".",
           );
         } else {
           lines.push(
-            "If you complete the delegated work and want the lead bot to continue or summarize, include contract.type=\"summary_request\" with the summary_bot set to the designated summary bot.",
+            "If any other expected responder besides this bot still remains in the current execution contract, do not emit contract.type=\"summary_request\" yet.",
+            "Only the final remaining contributor may hand control back to the designated summary bot with contract.type=\"summary_request\".",
             "Do not wake any third bot. Only the lead bot may delegate work publicly in this conversation.",
           );
         }

package/lib/runner-orchestration.mjs

@@ -710,6 +710,112 @@ function normalizeReplyExpectation(value, fallback = "informational") {
   return fallback;
 }
 
+function boolFromRunnerRaw(raw, fallback = false) {
+  if (raw === true || raw === false) {
+    return raw;
+  }
+  const normalized = String(raw ?? "").trim().toLowerCase();
+  if (!normalized) return fallback;
+  if (["1", "true", "yes", "y", "on"].includes(normalized)) {
+    return true;
+  }
+  if (["0", "false", "no", "n", "off"].includes(normalized)) {
+    return false;
+  }
+  return fallback;
+}
+
+function normalizeExecutionAssignmentMode(rawValue, fallback = "conversation_contribution") {
+  const normalized = String(rawValue || "").trim().toLowerCase();
+  if (!normalized) {
+    return fallback;
+  }
+  if ([
+    "execution_task",
+    "workspace_action",
+    "artifact_work",
+    "artifact_task",
+    "file_work",
+    "ctxpack_update",
+    "workitem_task",
+  ].includes(normalized)) {
+    return "execution_task";
+  }
+  if ([
+    "conversation_contribution",
+    "discussion_contribution",
+    "opinion",
+    "analysis",
+    "review",
+    "comparison",
+    "summary_contribution",
+    "greeting",
+    "reply",
+  ].includes(normalized)) {
+    return "conversation_contribution";
+  }
+  return fallback;
+}
+
+function normalizeExecutionAssignment(rawAssignment, {
+  allowedResponderSet = null,
+  currentBotSelector = "",
+  excludeCurrentTargetAssignments = false,
+} = {}) {
+  const assignment = safeObject(rawAssignment);
+  const targetBot = normalizeMentionSelector(
+    assignment.targetBot
+    || assignment.target_bot
+    || assignment.bot
+    || assignment.username,
+  );
+  const task = String(
+    assignment.task
+    || assignment.instruction
+    || assignment.assignment
+    || assignment.work
+    || assignment.description
+    || "",
+  ).trim();
+  if (!targetBot || !task) {
+    return null;
+  }
+  if (allowedResponderSet?.size && !allowedResponderSet.has(targetBot)) {
+    return null;
+  }
+  if (
+    excludeCurrentTargetAssignments === true
+    && currentBotSelector
+    && targetBot === normalizeMentionSelector(currentBotSelector)
+  ) {
+    return null;
+  }
+  const artifactsRequired = boolFromRunnerRaw(
+    assignment.artifactsRequired ?? assignment.artifacts_required,
+    false,
+  );
+  const workspaceAction = boolFromRunnerRaw(
+    assignment.workspaceAction ?? assignment.workspace_action,
+    false,
+  );
+  const mode = normalizeExecutionAssignmentMode(
+    assignment.mode
+    || assignment.assignment_mode
+    || assignment.kind
+    || assignment.type,
+    (artifactsRequired || workspaceAction) ? "execution_task" : "conversation_contribution",
+  );
+  const requiresExecution = mode === "execution_task" || artifactsRequired || workspaceAction;
+  return {
+    targetBot,
+    task,
+    mode,
+    artifactsRequired,
+    workspaceAction,
+    requiresExecution,
+  };
+}
+
 function normalizeHumanIntentType(value, fallback = "") {
   const normalized = String(value || "").trim().toLowerCase();
   if ([
@@ -1811,14 +1917,84 @@ function buildFallbackArchivedBotReplyConversationContext({
   };
 }
 
-function extractCurrentAssignmentTasks(conversationContext, currentBotSelector) {
+function extractCurrentAssignmentsForBot(conversationContext, currentBotSelector) {
   const currentSelector = normalizeMentionSelector(currentBotSelector);
   if (!currentSelector) return [];
   return ensureArray(safeObject(conversationContext?.executionContract).assignments)
     .map((item) => safeObject(item))
     .filter((item) => normalizeMentionSelector(item.targetBot || item.target_bot) === currentSelector)
-    .map((item) => String(item.task || item.instruction || "").trim())
-    .filter(Boolean);
+    .map((item) => ({
+      targetBot: normalizeMentionSelector(item.targetBot || item.target_bot),
+      task: String(item.task || item.instruction || "").trim(),
+      mode: normalizeExecutionAssignmentMode(
+        item.mode || item.assignment_mode || item.kind || item.type,
+        item.requiresExecution === true
+          || item.artifactsRequired === true
+          || item.workspaceAction === true
+          || item.artifacts_required === true
+          || item.workspace_action === true
+          ? "execution_task"
+          : "conversation_contribution",
+      ),
+      artifactsRequired: item.artifactsRequired === true || item.artifacts_required === true,
+      workspaceAction: item.workspaceAction === true || item.workspace_action === true,
+      requiresExecution: item.requiresExecution === true
+        || item.artifactsRequired === true
+        || item.workspaceAction === true
+        || item.artifacts_required === true
+        || item.workspace_action === true
+        || normalizeExecutionAssignmentMode(
+          item.mode || item.assignment_mode || item.kind || item.type,
+          "conversation_contribution",
+        ) === "execution_task",
+    }))
+    .filter((item) => item.task);
+}
+
+function summarizeCurrentAssignmentExecutionValidation(conversationContext, currentBotSelector) {
+  const assignments = extractCurrentAssignmentsForBot(conversationContext, currentBotSelector);
+  const assignmentModes = uniqueOrdered(
+    assignments.map((item) => String(item.mode || "").trim()).filter(Boolean),
+  );
+  const executionAssignments = assignments.filter((item) => item.requiresExecution === true);
+  const conversationAssignments = assignments.filter((item) => item.requiresExecution !== true);
+  if (!assignments.length) {
+    return {
+      status: "no_assignment",
+      reason: "no assignment for current bot in the active execution contract",
+      assignmentModes: [],
+      assignments: [],
+      executionAssignments: [],
+      conversationAssignments: [],
+      executionTasks: [],
+      allTasks: [],
+      requiresPlanner: false,
+    };
+  }
+  if (executionAssignments.length > 0) {
+    return {
+      status: "execution_assignment",
+      reason: "active assignment explicitly requires workspace/artifact execution",
+      assignmentModes,
+      assignments,
+      executionAssignments,
+      conversationAssignments,
+      executionTasks: executionAssignments.map((item) => String(item.task || "").trim()).filter(Boolean),
+      allTasks: assignments.map((item) => String(item.task || "").trim()).filter(Boolean),
+      requiresPlanner: true,
+    };
+  }
+  return {
+    status: "conversation_assignment",
+    reason: "active assignment is a conversational contribution and does not require planner/worker execution",
+    assignmentModes,
+    assignments,
+    executionAssignments: [],
+    conversationAssignments,
+    executionTasks: [],
+    allTasks: assignments.map((item) => String(item.task || "").trim()).filter(Boolean),
+    requiresPlanner: false,
+  };
 }
 
 function requiresArtifactsForExecutionStep(step) {
@@ -2557,6 +2733,7 @@ async function maybeExecuteDynamicRolePlan({
   saveRunnerRouteState,
   runRunnerAIExecution,
   validateWorkspaceArtifacts,
+  assignmentExecutionValidation = null,
 }) {
   const planner = typeof executionDeps.planRoleExecutionWithAI === "function"
     ? executionDeps.planRoleExecutionWithAI
@@ -2576,8 +2753,12 @@ async function maybeExecuteDynamicRolePlan({
   if (!planner || !resolveRunnerExecutionPlanForRole) {
     return null;
   }
-  const currentBotSelector = normalizeMentionSelector(bot?.username || bot?.name);
-  const assignmentTasks = extractCurrentAssignmentTasks(conversationContext, currentBotSelector);
+  const assignmentValidation = safeObject(assignmentExecutionValidation);
+  const assignmentValidationStatus = String(assignmentValidation.status || "").trim();
+  const assignmentValidationReason = String(assignmentValidation.reason || "").trim();
+  const assignmentTasks = ensureArray(assignmentValidation.executionTasks)
+    .map((item) => String(item || "").trim())
+    .filter(Boolean);
   const humanIntentType = normalizeHumanIntentType(
     safeObject(directHumanResponseContract).intentType
     || safeObject(safeObject(humanIntentContext).humanIntent).intentType,
@@ -2610,7 +2791,7 @@ async function maybeExecuteDynamicRolePlan({
   ) {
     return null;
   }
-  const shouldPlanExecution = assignmentTasks.length > 0 || (
+  const shouldPlanExecution = assignmentValidation.requiresPlanner === true || (
     triggerDecision.requiresDirectReply === true
     && humanIntentMode === "single_bot"
     && actionableReplyExpectation
@@ -2756,6 +2937,8 @@ async function maybeExecuteDynamicRolePlan({
         last_conversation_id: String(conversationContext?.id || "").trim(),
         last_conversation_stage: String(conversationContext?.stage || "").trim(),
         last_workspace_dir: String(executionPlan.workspaceDir || "").trim(),
+        last_assignment_validation_status: assignmentValidationStatus,
+        last_assignment_validation_reason: assignmentValidationReason,
         ...safeObject(intentStatePatch),
       }),
     );
@@ -2769,6 +2952,9 @@ async function maybeExecuteDynamicRolePlan({
         thread_id: archiveThread.threadID,
         comment_id: selectedRecord.id,
         trigger_kind: String(triggerDecision.trigger || "").trim(),
+        assignment_validation_status: assignmentValidationStatus,
+        assignment_validation_reason: assignmentValidationReason,
+        assignment_validation_modes: ensureArray(assignmentValidation.assignmentModes),
       },
     };
   }
@@ -2786,6 +2972,8 @@ async function maybeExecuteDynamicRolePlan({
         last_conversation_id: String(conversationContext?.id || "").trim(),
         last_conversation_stage: String(conversationContext?.stage || "").trim(),
         last_workspace_dir: String(executionPlan.workspaceDir || "").trim(),
+        last_assignment_validation_status: assignmentValidationStatus,
+        last_assignment_validation_reason: assignmentValidationReason,
         ...safeObject(intentStatePatch),
       }),
     );
@@ -2799,6 +2987,9 @@ async function maybeExecuteDynamicRolePlan({
         thread_id: archiveThread.threadID,
         comment_id: selectedRecord.id,
         trigger_kind: String(triggerDecision.trigger || "").trim(),
+        assignment_validation_status: assignmentValidationStatus,
+        assignment_validation_reason: assignmentValidationReason,
+        assignment_validation_modes: ensureArray(assignmentValidation.assignmentModes),
       },
     };
   }
@@ -2833,6 +3024,8 @@ async function maybeExecuteDynamicRolePlan({
           last_conversation_id: String(conversationContext?.id || "").trim(),
           last_conversation_stage: String(conversationContext?.stage || "").trim(),
           last_workspace_dir: String(executionPlan.workspaceDir || "").trim(),
+          last_assignment_validation_status: assignmentValidationStatus,
+          last_assignment_validation_reason: assignmentValidationReason,
           ...safeObject(intentStatePatch),
         }),
       );
@@ -2846,6 +3039,9 @@ async function maybeExecuteDynamicRolePlan({
           thread_id: archiveThread.threadID,
           comment_id: selectedRecord.id,
           trigger_kind: String(triggerDecision.trigger || "").trim(),
+          assignment_validation_status: assignmentValidationStatus,
+          assignment_validation_reason: assignmentValidationReason,
+          assignment_validation_modes: ensureArray(assignmentValidation.assignmentModes),
         },
       };
     }
@@ -2862,6 +3058,8 @@ async function maybeExecuteDynamicRolePlan({
           last_conversation_id: String(conversationContext?.id || "").trim(),
           last_conversation_stage: String(conversationContext?.stage || "").trim(),
           last_workspace_dir: String(stepExecutionPlan.workspaceDir || executionPlan.workspaceDir || "").trim(),
+          last_assignment_validation_status: assignmentValidationStatus,
+          last_assignment_validation_reason: assignmentValidationReason,
           ...safeObject(intentStatePatch),
         }),
       );
@@ -2875,6 +3073,9 @@ async function maybeExecuteDynamicRolePlan({
           thread_id: archiveThread.threadID,
           comment_id: selectedRecord.id,
           trigger_kind: String(triggerDecision.trigger || "").trim(),
+          assignment_validation_status: assignmentValidationStatus,
+          assignment_validation_reason: assignmentValidationReason,
+          assignment_validation_modes: ensureArray(assignmentValidation.assignmentModes),
         },
       };
     }
@@ -2918,6 +3119,8 @@ async function maybeExecuteDynamicRolePlan({
           last_conversation_id: String(conversationContext?.id || "").trim(),
           last_conversation_stage: String(conversationContext?.stage || "").trim(),
           last_workspace_dir: String(stepExecutionPlan.workspaceDir || executionPlan.workspaceDir || "").trim(),
+          last_assignment_validation_status: assignmentValidationStatus,
+          last_assignment_validation_reason: assignmentValidationReason,
           ...safeObject(intentStatePatch),
         }),
       );
@@ -2931,6 +3134,9 @@ async function maybeExecuteDynamicRolePlan({
           thread_id: archiveThread.threadID,
           comment_id: selectedRecord.id,
           trigger_kind: String(triggerDecision.trigger || "").trim(),
+          assignment_validation_status: assignmentValidationStatus,
+          assignment_validation_reason: assignmentValidationReason,
+          assignment_validation_modes: ensureArray(assignmentValidation.assignmentModes),
         },
       };
     }
@@ -3057,6 +3263,8 @@ async function maybeExecuteDynamicRolePlan({
           last_artifact_errors: stepErrors,
           last_boundary_violations: stepBoundaryViolations,
           last_workspace_dir: String(stepExecutionPlan.workspaceDir || executionPlan.workspaceDir || "").trim(),
+          last_assignment_validation_status: assignmentValidationStatus,
+          last_assignment_validation_reason: assignmentValidationReason,
           ...safeObject(intentStatePatch),
         }),
       );
@@ -3073,6 +3281,9 @@ async function maybeExecuteDynamicRolePlan({
           artifact_validation: String(stepValidation.status || "").trim() || "execution_failed",
           artifact_paths: summarizeValidatedArtifactPaths(stepValidation),
           artifact_errors: stepErrors,
+          assignment_validation_status: assignmentValidationStatus,
+          assignment_validation_reason: assignmentValidationReason,
+          assignment_validation_modes: ensureArray(assignmentValidation.assignmentModes),
         },
       };
     }
@@ -3117,21 +3328,13 @@ async function maybeExecuteDynamicRolePlan({
     mergedWorkItems,
   );
   const summaryBotSelector = normalizeMentionSelector(conversationContext?.summaryBotUsername || conversationContext?.leadBotUsername);
-  const finalContract = conversationContext?.mode === "public_multi_bot" && summaryBotSelector && summaryBotSelector !== currentBotSelector
-    ? {
-        type: "summary_request",
-        actionable: true,
-        assignments: [],
-        summaryBot: summaryBotSelector,
-        nextResponders: [summaryBotSelector],
-      }
-    : {
-        type: summaryRole === "approval" ? "final_summary" : "direct_result",
-        actionable: true,
-        assignments: [],
-        summaryBot: summaryBotSelector,
-        nextResponders: [],
-      };
+  const finalContract = {
+    type: summaryRole === "approval" ? "final_summary" : "direct_result",
+    actionable: true,
+    assignments: [],
+    summaryBot: summaryBotSelector,
+    nextResponders: [],
+  };
   return {
     kind: "executed",
     aiResult: {
@@ -3380,47 +3583,21 @@ function normalizeConversationExecutionContract(
     || contract.contractType
     || "",
   ).trim().toLowerCase();
-  const normalizedType = [
-    "direct_result",
-    "delegation",
-    "summary_request",
-    "final_summary",
-  ].includes(type)
-    ? type
-    : "";
-  const assignments = ensureArray(contract.assignments)
-    .map((item) => {
-      const assignment = safeObject(item);
-      const targetBot = normalizeMentionSelector(
-        assignment.targetBot
-        || assignment.target_bot
-        || assignment.bot
-        || assignment.username,
-      );
-      const task = String(
-        assignment.task
-        || assignment.instruction
-        || assignment.assignment
-        || assignment.work
-        || assignment.description
-        || "",
-      ).trim();
-      if (!targetBot || !task) {
-        return null;
-      }
-      if (allowedResponderSet.size && !allowedResponderSet.has(targetBot)) {
-        return null;
-      }
-      if (
-        excludeCurrentTargetAssignments === true
-        && currentBotSelector
-        && targetBot === normalizeMentionSelector(currentBotSelector)
-      ) {
-        return null;
-      }
-      return { targetBot, task };
-    })
-    .filter(Boolean);
+  const normalizedType = [
+    "direct_result",
+    "delegation",
+    "summary_request",
+    "final_summary",
+  ].includes(type)
+    ? type
+    : "";
+  const assignments = ensureArray(contract.assignments)
+    .map((item) => normalizeExecutionAssignment(item, {
+      allowedResponderSet,
+      currentBotSelector,
+      excludeCurrentTargetAssignments,
+    }))
+    .filter(Boolean);
   const summaryBot = normalizeMentionSelector(
     contract.summaryBot
     || contract.summary_bot
@@ -3483,30 +3660,10 @@ function normalizeResponseExecutionContract(rawContract, responseContract, { cur
     return null;
   }
   const assignments = ensureArray(contract.assignments)
-    .map((item) => {
-      const assignment = safeObject(item);
-      const targetBot = normalizeMentionSelector(
-        assignment.targetBot
-        || assignment.target_bot
-        || assignment.bot
-        || assignment.username,
-      );
-      const task = String(
-        assignment.task
-        || assignment.instruction
-        || assignment.assignment
-        || assignment.work
-        || assignment.description
-        || "",
-      ).trim();
-      if (!targetBot || !task) {
-        return null;
-      }
-      if (currentBotSelector && targetBot === currentBotSelector) {
-        return null;
-      }
-      return { targetBot, task };
-    })
+    .map((item) => normalizeExecutionAssignment(item, {
+      currentBotSelector,
+      excludeCurrentTargetAssignments: true,
+    }))
     .filter(Boolean);
   const summaryBot = normalizeMentionSelector(
     contract.summaryBot
@@ -4826,6 +4983,10 @@ export async function processRunnerSelectedRecord({
     directQueryReply: directInformationalReply,
     responderAdjudication,
   });
+  const assignmentExecutionValidation = summarizeCurrentAssignmentExecutionValidation(
+    conversationContext,
+    currentBotSelector,
+  );
   const emitRunnerStage = (phase, detail) => {
     if (!reportRunnerStage) return;
     try {
@@ -4981,6 +5142,7 @@ export async function processRunnerSelectedRecord({
       saveRunnerRouteState,
       runRunnerAIExecution,
       validateWorkspaceArtifacts,
+      assignmentExecutionValidation,
     });
     if (dynamicRoleExecution?.kind === "error") {
       dynamicExecutionError = dynamicRoleExecution.result;
@@ -5317,13 +5479,19 @@ export async function processRunnerSelectedRecord({
   if (effectiveConversationContext?.mode === "public_multi_bot") {
     const currentBotSelector = normalizeMentionSelector(bot?.username || bot?.name);
     const currentSession = safeObject(effectiveConversationContext.session);
+    const currentExecutionContract = safeObject(effectiveConversationContext.executionContract);
     const normalizedReplyFingerprint = normalizeConversationReplyFingerprint(sanitizedReplyText);
     const lastSpeaker = normalizeMentionSelector(currentSession.last_speaker_bot_username);
     const lastReplyFingerprintByBot = safeObject(currentSession.last_reply_fingerprint_by_bot);
-    if (lastSpeaker && lastSpeaker === currentBotSelector) {
-      const reason = "conversation guard blocked consecutive reply from the same bot";
-      saveRunnerRouteState(
-        routeKey,
+    const contractAuthorizedResponders = uniqueOrdered([
+      ...collectExecutionContractNextResponders(currentExecutionContract),
+      normalizeMentionSelector(currentExecutionContract.summaryBot || currentExecutionContract.summary_bot),
+    ].filter(Boolean));
+    const contractAuthorizesCurrentBotReply = contractAuthorizedResponders.includes(currentBotSelector);
+    if (lastSpeaker && lastSpeaker === currentBotSelector && !contractAuthorizesCurrentBotReply) {
+      const reason = "conversation guard blocked consecutive reply from the same bot";
+      saveRunnerRouteState(
+        routeKey,
         buildRunnerRouteStateFromComment(selectedRecord, {
           last_action: "conversation_skipped",
           last_reason: reason,
@@ -5433,6 +5601,8 @@ export async function processRunnerSelectedRecord({
         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_speaker_bot_username: normalizeMentionSelector(bot?.username || bot?.name),
         last_workspace_dir: String(effectiveExecutionPlan.workspaceDir || "").trim(),
         ...intentStatePatch,
@@ -5474,6 +5644,9 @@ export async function processRunnerSelectedRecord({
         response_contract_validation_status: String(responseContractValidation.status || "").trim(),
         response_contract_validation_reason: String(responseContractValidation.reason || "").trim(),
         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),
         reply_chars: String(sanitizedReplyText || "").length,
         execution_mode: effectiveExecutionPlan.mode,
         role_profile: effectiveExecutionPlan.roleProfileName,
@@ -5564,6 +5737,8 @@ export async function processRunnerSelectedRecord({
         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"
           ? [
@@ -5664,6 +5839,9 @@ export async function processRunnerSelectedRecord({
       response_contract_validation_status: String(responseContractValidation.status || "").trim(),
       response_contract_validation_reason: String(responseContractValidation.reason || "").trim(),
       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),
       delivery_status: deliveryResult.delivery.dryRun ? "dry_run" : "delivered",
       execution_mode: effectiveExecutionPlan.mode,
       role_profile: effectiveExecutionPlan.roleProfileName,

package/lib/selftest-runner-scenarios.mjs

@@ -5483,9 +5483,9 @@ export async function runSelftestRunnerScenarios(push, deps) {
     push("single_bot_execution_failure_uses_ai_failure_explainer_when_available", false, String(err?.message || err));
   }
 
-  try {
-    let aiCalls = 0;
-    const processed = await processRunnerSelectedRecord({
+  try {
+    let aiCalls = 0;
+    const processed = await processRunnerSelectedRecord({
       routeKey: "single-bot-informational-human-request-key",
       normalizedRoute: normalizeRunnerRoute({
         name: "telegram-monitor-single-bot-informational",
@@ -9087,13 +9087,164 @@ 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_lead_reply_can_wake_named_peer", false, String(err?.message || err));
-  }
-
-  try {
-    let aiCalls = 0;
-    const deliveredConversation = [];
+  } catch (err) {
+    push("delegated_single_lead_lead_reply_can_wake_named_peer", false, String(err?.message || err));
+  }
+
+  try {
+    let aiCalls = 0;
+    let plannerCalls = 0;
+    const processed = await processRunnerSelectedRecord({
+      routeKey: "delegated-single-lead-conversation-assignment-skips-planner-key",
+      normalizedRoute: normalizeRunnerRoute({
+        name: "telegram-monitor-delegated-single-lead-conversation-assignment-skips-planner",
+        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,
+        },
+        archive_policy: {
+          mirror_replies: true,
+          dedupe_inbound: true,
+          dedupe_outbound: true,
+          skip_bot_messages: true,
+        },
+        dry_run_delivery: true,
+      }),
+      selectedRecord: {
+        id: "comment-delegated-single-lead-conversation-assignment-skips-planner",
+        createdAt: "2026-03-16T00:02:12.000Z",
+        parsedArchive: {
+          kind: "bot_reply",
+          conversationID: "comment-delegated-single-lead-conversation-open",
+          conversationMode: "public_multi_bot",
+          conversationStage: "bot_reply",
+          conversationIntentMode: "delegated_single_lead",
+          conversationAllowBotToBot: true,
+          conversationLeadBotUsername: "ryoai_bot",
+          conversationParticipants: ["ryoai_bot", "ryoai2_bot", "ryoai3_bot"],
+          conversationInitialResponders: ["ryoai_bot"],
+          conversationAllowedResponders: ["ryoai_bot", "ryoai2_bot", "ryoai3_bot"],
+          conversationSummaryBotUsername: "ryoai_bot",
+          botUsername: "RyoAI_bot",
+          botName: "RyoAI_bot",
+          sender: "RyoAI_bot",
+          body: "@RyoAI2_bot 관점 하나만 짧게 말해줘.",
+          mentionUsernames: ["ryoai2_bot"],
+          executionContract: {
+            type: "delegation",
+            actionable: true,
+            assignments: [
+              { target_bot: "ryoai2_bot", task: "관점 하나만 짧게 말해줘.", mode: "conversation_contribution", artifacts_required: false },
+            ],
+            summary_bot: "ryoai_bot",
+            next_responders: ["ryoai2_bot"],
+          },
+        },
+      },
+      pendingOrdered: [],
+      bot: {
+        id: "bot-peer-1",
+        name: "RyoAI2_bot",
+        username: "RyoAI2_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: path.join(os.tmpdir(), "metheus-runner-selftest-conversation-assignment-skips-planner"),
+        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 () => {
+          aiCalls += 1;
+          return {
+            skip: false,
+            reply: "제 관점에서는 범위와 우선순위를 먼저 고정하는 게 맞습니다.",
+            contract: {
+              type: "summary_request",
+              actionable: true,
+              assignments: [],
+              summary_bot: "ryoai_bot",
+              next_responders: ["ryoai_bot"],
+            },
+          };
+        },
+        performLocalBotDelivery: async () => ({
+          delivery: { dryRun: true, body: {} },
+          archive: {},
+        }),
+        serializeRunnerTriggerPolicy: (value) => value,
+        serializeRunnerArchivePolicy: (value) => value,
+        buildRunnerExecutionDeps: () => ({
+          planRoleExecutionWithAI: async () => {
+            plannerCalls += 1;
+            return {
+              requiresExecution: true,
+              summaryRole: "worker",
+              steps: [{ role: "worker", goal: "unexpected", artifactsRequired: true }],
+            };
+          },
+        }),
+        buildRunnerDeliveryDeps: () => ({}),
+        buildRunnerRuntimeDeps: () => ({}),
+        resolveConversationPeerBots: () => [
+          { id: "bot-lead-1", name: "RyoAI_bot" },
+          { id: "bot-peer-1", name: "RyoAI2_bot" },
+          { id: "bot-peer-2", name: "RyoAI3_bot" },
+        ],
+      },
+    });
+    push(
+      "delegated_single_lead_conversation_assignment_skips_planner",
+      processed.kind === "replied"
+        && aiCalls === 1
+        && plannerCalls === 0
+        && String(processed.result?.assignment_validation_status || "") === "conversation_assignment"
+        && ensureArray(processed.result?.assignment_validation_modes).includes("conversation_contribution"),
+      `kind=${String(processed.kind || "(none)")} ai_calls=${aiCalls} planner_calls=${plannerCalls} assignment_status=${String(processed.result?.assignment_validation_status || "(none)")} modes=${JSON.stringify(processed.result?.assignment_validation_modes || [])}`,
+    );
+  } catch (err) {
+    push("delegated_single_lead_conversation_assignment_skips_planner", false, String(err?.message || err));
+  }
+
+  try {
+    let aiCalls = 0;
+    const deliveredConversation = [];
     const processed = await processRunnerSelectedRecord({
       routeKey: "delegated-single-lead-restored-bot-reply-key",
       normalizedRoute: normalizeRunnerRoute({

package/package.json

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