metheus-governance-mcp-cli 0.2.266 → 0.2.268

package/cli.mjs

@@ -6223,20 +6223,26 @@ function markRunnerRequestLifecycle({
     return String(existing.normalized_intent || "").trim().toLowerCase();
   })();
   const normalizedOutcome = String(outcome || "").trim().toLowerCase();
-  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";
-    }
-    if (normalizedOutcome === "loop_closed") return "loop_closed";
-    if (normalizedOutcome === "expired") return "expired";
-    if (normalizedOutcome === "error" || normalizedOutcome === "skipped" || normalizedOutcome === "closed") {
-      return "closed";
-    }
-    return normalizeRunnerRequestStatus(existing.status);
-  })();
+  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";
+    }
+    if (normalizedOutcome === "loop_closed") return "loop_closed";
+    if (normalizedOutcome === "expired") return "expired";
+    if (
+      normalizedOutcome === "error"
+      || normalizedOutcome === "skipped"
+      || normalizedOutcome === "closed"
+      || normalizedOutcome === "execution_failed"
+      || normalizedOutcome === "policy_violation"
+    ) {
+      return "closed";
+    }
+    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);

package/lib/runner-orchestration-step-inputs.mjs

@@ -9,6 +9,73 @@ function ensureArray(value) {
   return Array.isArray(value) ? value : [];
 }
 
+function normalizeConversationHeuristicText(text) {
+  return String(text || "")
+    .trim()
+    .toLowerCase()
+    .replace(/\s+/g, " ");
+}
+
+function isImplicitSingleBotConversationContribution(taskText = "") {
+  const normalizedText = normalizeConversationHeuristicText(taskText);
+  if (!normalizedText) {
+    return false;
+  }
+  const workspaceArtifactPatterns = [
+    /\bfile\b/,
+    /\bfiles\b/,
+    /\bcode\b/,
+    /\bpatch\b/,
+    /\bcommit\b/,
+    /\bworkspace\b/,
+    /\brepo\b/,
+    /\brepository\b/,
+    /\bctxpack\b/,
+    /\bwork ?item\b/,
+    /\bevidence\b/,
+    /\bartifact\b/,
+    /\bimplement\b/,
+    /\bimplementation\b/,
+    /\bfix\b/,
+    /\bupdate\b/,
+    /\bedit\b/,
+    /\bcreate\b.*\b(document|doc|guide|plan|readme)\b/,
+    /\bwrite\b.*\b(document|doc|guide|plan|readme)\b/,
+    /\uD30C\uC77C/,
+    /\uCF54\uB4DC/,
+    /\uBB38\uC11C/,
+    /\uAD6C\uD604/,
+    /\uC218\uC815/,
+    /\uC791\uC131/,
+    /\uC544\uD2F0\uD329\uD2B8/,
+    /\uC99D\uAC70/,
+    /\uC6CC\uD06C\uC2A4\uD398\uC774\uC2A4/,
+    /\uCEE4\uBC0B/,
+  ];
+  if (workspaceArtifactPatterns.some((pattern) => pattern.test(normalizedText))) {
+    return false;
+  }
+  const conversationalPatterns = [
+    /\bgreet\b/,
+    /\bhello\b/,
+    /\bhi\b/,
+    /\bsay hello\b/,
+    /\bintroduce yourself\b/,
+    /\banswer briefly\b/,
+    /\breply briefly\b/,
+    /\bin this room\b/,
+    /\bone line\b/,
+    /\uC778\uC0AC/,
+    /\uC548\uB155/,
+    /\uD558\uC774/,
+    /\uC18C\uAC1C/,
+    /\uD55C ?\uC904/,
+    /\uC9E7\uAC8C/,
+    /\uB2F5\uD574/,
+  ];
+  return conversationalPatterns.some((pattern) => pattern.test(normalizedText));
+}
+
 export function resolveInformationalQueryExecutionPlan(executionPlan, directInformationalReply, route) {
   const basePlan = safeObject(executionPlan);
   const override = safeObject(safeObject(directInformationalReply).execution_override);
@@ -151,6 +218,27 @@ export function summarizeCurrentAssignmentExecutionValidation(
     )
     && Boolean(implicitExecutionTask);
   if (!assignments.length) {
+    if (shouldUseImplicitSingleBotExecution && isImplicitSingleBotConversationContribution(implicitExecutionTask)) {
+      const implicitConversationAssignment = {
+        targetBot: currentSelector,
+        task: implicitExecutionTask,
+        mode: "conversation_contribution",
+        artifactsRequired: false,
+        workspaceAction: false,
+        requiresExecution: false,
+      };
+      return {
+        status: "conversation_assignment",
+        reason: "single-bot public conversational contribution does not require planner/worker execution",
+        assignmentModes: ["conversation_contribution"],
+        assignments: [implicitConversationAssignment],
+        executionAssignments: [],
+        conversationAssignments: [implicitConversationAssignment],
+        executionTasks: [],
+        allTasks: [implicitExecutionTask],
+        requiresPlanner: false,
+      };
+    }
     if (shouldUseImplicitSingleBotExecution) {
       const implicitAssignment = {
         targetBot: currentSelector,

package/lib/selftest-runner-scenarios.mjs

@@ -2615,16 +2615,61 @@ export async function runSelftestRunnerScenarios(push, deps) {
       executionContractTargets: ["@RyoAI3_bot"],
       nextExpectedResponders: [],
     });
-    push(
-      "runner_request_lifecycle_reply_ignores_session_state_when_continuation_targets_remain",
-      String(continuedRequest?.status || "") === "running",
-      `status=${String(continuedRequest?.status || "(none)")}`,
-    );
-
-    saveBotRunnerState({
-      routes: {
-        [requestRouteKey]: {},
-      },
+    push(
+      "runner_request_lifecycle_reply_ignores_session_state_when_continuation_targets_remain",
+      String(continuedRequest?.status || "") === "running",
+      `status=${String(continuedRequest?.status || "(none)")}`,
+    );
+
+    saveBotRunnerState({
+      routes: {
+        [requestRouteKey]: {},
+      },
+      sharedInboxes: {},
+      excludedComments: {},
+      requests: {
+        "request-key-2b": {
+          request_key: "request-key-2b",
+          project_id: selftestProjectID,
+          provider: "telegram",
+          chat_id: "-100123",
+          source_message_id: 711,
+          conversation_id: "conv-request-2b",
+          status: "running",
+          claimed_by_route: requestRouteKey,
+        },
+      },
+      consumedComments: {},
+    });
+    const failedRequest = markRunnerRequestLifecycle({
+      normalizedRoute: requestRoute,
+      requestKey: "request-key-2b",
+      selectedRecord: {
+        id: "comment-request-finish-2b",
+        parsedArchive: {
+          kind: "bot_reply",
+          chatID: "-100123",
+          messageID: 712,
+          conversationID: "conv-request-2b",
+        },
+      },
+      routeKey: requestRouteKey,
+      outcome: "execution_failed",
+      closedReason: "worker step completed without any validated project artifacts",
+      currentBotSelector: "@RyoAI_bot",
+    });
+    push(
+      "runner_request_lifecycle_execution_failed_closes_request",
+      String(failedRequest?.status || "") === "closed"
+        && String(failedRequest?.closed_reason || "") === "worker step completed without any validated project artifacts"
+        && String(failedRequest?.closed_at || "").trim().length > 0,
+      `status=${String(failedRequest?.status || "(none)")} reason=${String(failedRequest?.closed_reason || "(none)")} closed_at=${String(failedRequest?.closed_at || "(none)")}`,
+    );
+
+    saveBotRunnerState({
+      routes: {
+        [requestRouteKey]: {},
+      },
       sharedInboxes: {},
       excludedComments: {},
       requests: {
@@ -2679,12 +2724,13 @@ export async function runSelftestRunnerScenarios(push, deps) {
     );
   } catch (err) {
     push("runner_request_claim_persists_request_and_consumed_comment", false, String(err?.message || err));
-    push("runner_stale_open_session_cleanup_excludes_bot_reply_replay", false, String(err?.message || err));
-    push("runner_request_lifecycle_reply_completes_without_continuation_targets", false, String(err?.message || err));
-    push("runner_request_lifecycle_reply_ignores_session_state_when_continuation_targets_remain", false, String(err?.message || err));
-    push("runner_request_claim_preserves_authoritative_source_message_envelope", false, String(err?.message || err));
-    push("runner_request_lifecycle_preserves_stronger_existing_source_ownership", false, String(err?.message || err));
-  } finally {
+    push("runner_stale_open_session_cleanup_excludes_bot_reply_replay", false, String(err?.message || err));
+    push("runner_request_lifecycle_reply_completes_without_continuation_targets", false, String(err?.message || err));
+    push("runner_request_lifecycle_reply_ignores_session_state_when_continuation_targets_remain", false, String(err?.message || err));
+    push("runner_request_lifecycle_execution_failed_closes_request", false, String(err?.message || err));
+    push("runner_request_claim_preserves_authoritative_source_message_envelope", false, String(err?.message || err));
+    push("runner_request_lifecycle_preserves_stronger_existing_source_ownership", false, String(err?.message || err));
+  } finally {
     if (typeof originalRequestLedgerHome === "string") {
       process.env.HOME = originalRequestLedgerHome;
     } else {
@@ -6044,15 +6090,159 @@ export async function runSelftestRunnerScenarios(push, deps) {
         && deliveredText === "I will inspect the project first and come back later.",
       `kind=${String(processed.kind || "(none)")} outcome=${String(processed.result?.outcome || "(none)")} ai_calls=${aiCalls} delivery_calls=${deliveryCalls} delivered=${deliveredText} reason=${String(processed.result?.detail || "(none)")}`,
     );
-  } catch (err) {
-    push("single_bot_human_work_request_requires_actionable_contract", false, String(err?.message || err));
-  }
-
-  try {
-    let aiCalls = 0;
-    let deliveryCalls = 0;
-    let deliveredText = "";
-    let capturedFailureFacts = null;
+  } catch (err) {
+    push("single_bot_human_work_request_requires_actionable_contract", false, String(err?.message || err));
+  }
+
+  try {
+    let aiCalls = 0;
+    let plannerCalls = 0;
+    let deliveryCalls = 0;
+    let deliveredText = "";
+    const processed = await processRunnerSelectedRecord({
+      routeKey: "single-bot-conversation-greeting-request-key",
+      normalizedRoute: normalizeRunnerRoute({
+        name: "telegram-monitor-single-bot-conversation-greeting",
+        project_id: selftestProjectID,
+        provider: "telegram",
+        role: "monitor",
+        role_profile: "monitor",
+        destination_id: "dest-1",
+        destination_label: "Main Room",
+        server_bot_name: "RyoAI_bot",
+        server_bot_id: "bot-lead-1",
+        trigger_policy: {
+          mentions_only: true,
+          direct_messages: true,
+          reply_to_bot_messages: true,
+        },
+        archive_policy: {
+          mirror_replies: true,
+          dedupe_inbound: true,
+          dedupe_outbound: true,
+          skip_bot_messages: true,
+        },
+        dry_run_delivery: true,
+      }),
+      selectedRecord: {
+        id: "comment-single-bot-conversation-greeting-request",
+        createdAt: "2026-03-31T08:37:56.000Z",
+        parsedArchive: {
+          kind: "telegram_message",
+          chatID: "-100123",
+          chatType: "supergroup",
+          senderIsBot: false,
+          body: "@RyoAI_bot 당신이 @SangHoon01_bot 에게 인사해보세요.",
+          mentionUsernames: ["RyoAI_bot", "SangHoon01_bot"],
+          messageID: 1057,
+        },
+      },
+      pendingOrdered: [],
+      bot: {
+        id: "bot-lead-1",
+        name: "RyoAI_bot",
+        username: "RyoAI_bot",
+        role: "monitor",
+        provider: "telegram",
+      },
+      destination: {
+        id: "dest-1",
+        label: "Main Room",
+        provider: "telegram",
+        chatID: "-100123",
+      },
+      archiveThread: {
+        threadID: "thread-1",
+        workItemID: "work-item-1",
+      },
+      executionPlan: {
+        mode: "role_profile",
+        roleProfileName: "monitor",
+        roleProfile: {
+          client: "sample",
+          model: "",
+          permissionMode: "read_only",
+          reasoningEffort: "low",
+        },
+        workspaceDir: path.join(os.tmpdir(), "metheus-runner-selftest-single-bot-conversation-greeting"),
+        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: "@SangHoon01_bot 안녕하세요.",
+            replyToMessageID: 0,
+          };
+        },
+        performLocalBotDelivery: async ({ text }) => {
+          deliveryCalls += 1;
+          deliveredText = String(text || "").trim();
+          return {
+            delivery: { dryRun: true, body: {} },
+            archive: {},
+          };
+        },
+        serializeRunnerTriggerPolicy: (value) => value,
+        serializeRunnerArchivePolicy: (value) => value,
+        buildRunnerExecutionDeps: () => ({
+          analyzeHumanConversationIntentWithAI: async () => ({
+            mode: "single_bot",
+            lead_bot: "ryoai_bot",
+            participants: ["ryoai_bot"],
+            initial_responders: ["ryoai_bot"],
+            allowed_responders: ["ryoai_bot"],
+            summary_bot: "",
+            allow_bot_to_bot: false,
+            reply_expectation: "actionable",
+            intent_type: "general_execution",
+          }),
+          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" },
+        ],
+      },
+    });
+    push(
+      "single_bot_conversational_greeting_request_skips_planner_and_worker",
+      processed.kind === "replied"
+        && aiCalls === 1
+        && plannerCalls === 0
+        && deliveryCalls === 1
+        && String(processed.result?.assignment_validation_status || "") === "conversation_assignment"
+        && ensureArray(processed.result?.assignment_validation_modes).includes("conversation_contribution")
+        && deliveredText === "@SangHoon01_bot 안녕하세요.",
+      `kind=${String(processed.kind || "(none)")} ai_calls=${aiCalls} planner_calls=${plannerCalls} delivery_calls=${deliveryCalls} assignment_status=${String(processed.result?.assignment_validation_status || "(none)")} modes=${JSON.stringify(processed.result?.assignment_validation_modes || [])} delivered=${String(deliveredText || "(none)")}`,
+    );
+  } catch (err) {
+    push("single_bot_conversational_greeting_request_skips_planner_and_worker", false, String(err?.message || err));
+  }
+
+  try {
+    let aiCalls = 0;
+    let deliveryCalls = 0;
+    let deliveredText = "";
+    let capturedFailureFacts = null;
     const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), "metheus-runner-selftest-ai-failure-explainer-"));
     const processed = await processRunnerSelectedRecord({
       routeKey: "single-bot-human-work-request-ai-failure-explainer-key",

package/package.json

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