metheus-governance-mcp-cli 0.2.263 → 0.2.264

package/cli.mjs

@@ -831,9 +831,17 @@ function botRunnerWorkspaceRegistryFilePath() {
   return resolveHomeFilePath(BOT_RUNNER_WORKSPACE_REGISTRY_RELATIVE_PATH);
 }
 
-function botRunnerStateFilePath() {
-  return resolveHomeFilePath(BOT_RUNNER_STATE_RELATIVE_PATH);
-}
+function botRunnerStateFilePath() {
+  return resolveHomeFilePath(BOT_RUNNER_STATE_RELATIVE_PATH);
+}
+
+function botRunnerStateBackupFilePath(filePath = botRunnerStateFilePath()) {
+  const normalizedPath = String(filePath || "").trim();
+  if (!normalizedPath) {
+    return "";
+  }
+  return `${normalizedPath}.bak`;
+}
 
 function botRunnerProcessesFilePath() {
   return resolveHomeFilePath(BOT_RUNNER_PROCESSES_RELATIVE_PATH);
@@ -2200,25 +2208,37 @@ function migrateBotRunnerStateRoutes(routes, runnerConfig) {
   };
 }
 
-function loadBotRunnerState() {
-  const filePath = botRunnerStateFilePath();
-  waitForBotRunnerStateLockRelease(filePath);
-  try {
-    if (!fs.existsSync(filePath)) {
-      return {
-        filePath,
-        routes: {},
-        sharedInboxes: {},
-        excludedComments: {},
-        requests: {},
-        consumedComments: {},
-        migrated: false,
-        migratedKeys: [],
-        remainingAnonymousKeys: [],
-      };
-    }
-    const parsed = tryJsonParse(fs.readFileSync(filePath, "utf8"));
-    const runnerConfig = loadBotRunnerConfig({ persistIfNeeded: true });
+function loadBotRunnerState() {
+  const filePath = botRunnerStateFilePath();
+  const backupPath = botRunnerStateBackupFilePath(filePath);
+  waitForBotRunnerStateLockRelease(filePath);
+  const emptyState = {
+    filePath,
+    routes: {},
+    sharedInboxes: {},
+    excludedComments: {},
+    requests: {},
+    consumedComments: {},
+    migrated: false,
+    migratedKeys: [],
+    remainingAnonymousKeys: [],
+  };
+  try {
+    if (!fs.existsSync(filePath)) {
+      return emptyState;
+    }
+    let parsed = tryJsonParse(fs.readFileSync(filePath, "utf8"));
+    if ((!parsed || typeof parsed !== "object" || Array.isArray(parsed)) && backupPath && fs.existsSync(backupPath)) {
+      const backupParsed = tryJsonParse(fs.readFileSync(backupPath, "utf8"));
+      if (backupParsed && typeof backupParsed === "object" && !Array.isArray(backupParsed)) {
+        parsed = backupParsed;
+        writeTextFileAtomic(filePath, `${JSON.stringify(backupParsed, null, 2)}\n`);
+      }
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return emptyState;
+    }
+    const runnerConfig = loadBotRunnerConfig({ persistIfNeeded: true });
     const migratedState = migrateBotRunnerStateRoutes(safeObject(parsed?.routes), runnerConfig);
     if (migratedState.changed) {
       saveBotRunnerState({
@@ -2241,24 +2261,14 @@ function loadBotRunnerState() {
       excludedComments: normalizeBotRunnerExcludedComments(parsed?.excluded_comments || parsed?.excludedComments),
       requests: normalizeBotRunnerRequests(parsed?.requests),
       consumedComments: normalizeBotRunnerConsumedComments(parsed?.consumed_comments || parsed?.consumedComments),
-      migrated: migratedState.changed,
-      migratedKeys: migratedState.migratedKeys,
-      remainingAnonymousKeys: migratedState.remainingAnonymousKeys,
-    };
-  } catch {
-    return {
-      filePath,
-      routes: {},
-      sharedInboxes: {},
-      excludedComments: {},
-      requests: {},
-      consumedComments: {},
-      migrated: false,
-      migratedKeys: [],
-      remainingAnonymousKeys: [],
-    };
-  }
-}
+      migrated: migratedState.changed,
+      migratedKeys: migratedState.migratedKeys,
+      remainingAnonymousKeys: migratedState.remainingAnonymousKeys,
+    };
+  } catch {
+    return emptyState;
+  }
+}
 
 function sleepSyncMs(delayMs) {
   const ms = Number(delayMs) || 0;
@@ -2408,13 +2418,19 @@ function writeTextFileAtomic(filePath, text) {
   }
 }
 
-function saveBotRunnerState(nextState) {
-  const filePath = botRunnerStateFilePath();
-  return withBotRunnerStateFileLock(filePath, () => {
-    let current = {};
-    try {
-      current = safeObject(tryJsonParse(fs.readFileSync(filePath, "utf8")));
-    } catch {}
+function saveBotRunnerState(nextState) {
+  const filePath = botRunnerStateFilePath();
+  const backupPath = botRunnerStateBackupFilePath(filePath);
+  return withBotRunnerStateFileLock(filePath, () => {
+    let current = {};
+    try {
+      current = safeObject(tryJsonParse(fs.readFileSync(filePath, "utf8")));
+    } catch {}
+    if (!Object.keys(current).length && backupPath && fs.existsSync(backupPath)) {
+      try {
+        current = safeObject(tryJsonParse(fs.readFileSync(backupPath, "utf8")));
+      } catch {}
+    }
     const stateEntryTimestampMs = (...values) => {
       for (const value of values) {
         const ms = Date.parse(String(value || "").trim());
@@ -2562,7 +2578,7 @@ function saveBotRunnerState(nextState) {
       }
       return normalizeBotRunnerConsumedComments(merged);
     };
-    const payload = {
+    const payload = {
       version: 1,
       updated_at: new Date().toISOString(),
       routes: mergeRunnerStateRoutes(
@@ -2581,15 +2597,30 @@ function saveBotRunnerState(nextState) {
         current.requests,
         nextState?.requests ?? current.requests,
       ),
-      consumed_comments: mergeRunnerStateConsumedComments(
-        current.consumed_comments ?? current.consumedComments,
-        nextState?.consumedComments ?? nextState?.consumed_comments ?? current.consumed_comments ?? current.consumedComments,
-      ),
-    };
-    writeTextFileAtomic(filePath, `${JSON.stringify(payload, null, 2)}\n`);
-    return filePath;
-  });
-}
+      consumed_comments: mergeRunnerStateConsumedComments(
+        current.consumed_comments ?? current.consumedComments,
+        nextState?.consumedComments ?? nextState?.consumed_comments ?? current.consumed_comments ?? current.consumedComments,
+      ),
+    };
+    const serialized = `${JSON.stringify(payload, null, 2)}\n`;
+    writeTextFileAtomic(filePath, serialized);
+    const verifiedPayload = tryJsonParse(fs.readFileSync(filePath, "utf8"));
+    if (!verifiedPayload || typeof verifiedPayload !== "object" || Array.isArray(verifiedPayload)) {
+      if (backupPath && fs.existsSync(backupPath)) {
+        const backupRaw = fs.readFileSync(backupPath, "utf8");
+        const backupParsed = tryJsonParse(backupRaw);
+        if (backupParsed && typeof backupParsed === "object" && !Array.isArray(backupParsed)) {
+          writeTextFileAtomic(filePath, backupRaw);
+        }
+      }
+      throw new Error("bot runner state write verification failed");
+    }
+    if (backupPath) {
+      writeTextFileAtomic(backupPath, serialized);
+    }
+    return filePath;
+  });
+}
 
 function normalizeBotRunnerExcludedComments(rawExcluded, nowMs = Date.now()) {
   const normalized = {};

package/lib/runner-orchestration.mjs

@@ -1809,7 +1809,7 @@ export async function resolveRunnerPrecomputedSelectedRecordExecutionContext({
   };
 }
 
-function resolveRunnerDeliverySourceMessageEnvelope({
+export function resolveRunnerDeliverySourceMessageEnvelope({
   routeState,
   persistedRequest,
   selectedRecord,
@@ -1826,7 +1826,7 @@ function resolveRunnerDeliverySourceMessageEnvelope({
   if (Object.keys(safeObject(localMatch.envelope)).length > 0) {
     return localMatch.envelope;
   }
-  return safeObject(localMatch.candidates).archiveEnvelope || {};
+  return {};
 }
 
 function escapeRegExp(text) {

package/lib/selftest-runner-scenarios.mjs

@@ -2,7 +2,10 @@
 import http from "node:http";
 import os from "node:os";
 import path from "node:path";
-import process from "node:process";
+import process from "node:process";
+import {
+  resolveRunnerDeliverySourceMessageEnvelope,
+} from "./runner-orchestration.mjs";
 
 function requireDependency(deps, key) {
   const candidate = deps?.[key];
@@ -2745,6 +2748,66 @@ export async function runSelftestRunnerScenarios(push, deps) {
     }
   }
 
+  const originalStateBackupHome = process.env.HOME;
+  const originalStateBackupUserProfile = process.env.USERPROFILE;
+  let stateBackupTempRoot = "";
+  try {
+    stateBackupTempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "metheus-runner-selftest-state-backup-"));
+    process.env.HOME = stateBackupTempRoot;
+    process.env.USERPROFILE = stateBackupTempRoot;
+    const metheusDir = path.join(stateBackupTempRoot, ".metheus");
+    fs.mkdirSync(metheusDir, { recursive: true });
+    const statePath = path.join(metheusDir, "bot-runner-state.json");
+    const backupPath = `${statePath}.bak`;
+    fs.writeFileSync(
+      backupPath,
+      `${JSON.stringify({
+        version: 1,
+        updated_at: "2026-03-29T00:00:00.000Z",
+        routes: {
+          "telegram-monitor-state-backup::project::telegram::monitor::dest::actor": {
+            last_action: "idle",
+          },
+        },
+        shared_inboxes: {},
+        excluded_comments: {},
+        requests: {},
+        consumed_comments: {},
+      }, null, 2)}\n`,
+      "utf8",
+    );
+    fs.writeFileSync(statePath, "{ malformed json", "utf8");
+    const recoveredState = loadBotRunnerState();
+    const recoveredRouteState = safeObject(
+      safeObject(recoveredState.routes)["telegram-monitor-state-backup::project::telegram::monitor::dest::actor"],
+    );
+    const repairedPrimary = safeObject(tryJsonParse(fs.readFileSync(statePath, "utf8")));
+    push(
+      "runner_state_load_restores_primary_from_backup_when_primary_is_malformed",
+      String(recoveredRouteState.last_action || "") === "idle"
+        && String(safeObject(safeObject(repairedPrimary.routes)["telegram-monitor-state-backup::project::telegram::monitor::dest::actor"]).last_action || "") === "idle",
+      `recovered=${String(recoveredRouteState.last_action || "(none)")} repaired=${String(safeObject(safeObject(repairedPrimary.routes)["telegram-monitor-state-backup::project::telegram::monitor::dest::actor"]).last_action || "(none)")}`,
+    );
+  } catch (err) {
+    push("runner_state_load_restores_primary_from_backup_when_primary_is_malformed", false, String(err?.message || err));
+  } finally {
+    if (typeof originalStateBackupHome === "string") {
+      process.env.HOME = originalStateBackupHome;
+    } else {
+      delete process.env.HOME;
+    }
+    if (typeof originalStateBackupUserProfile === "string") {
+      process.env.USERPROFILE = originalStateBackupUserProfile;
+    } else {
+      delete process.env.USERPROFILE;
+    }
+    if (stateBackupTempRoot) {
+      try {
+        fs.rmSync(stateBackupTempRoot, { recursive: true, force: true });
+      } catch {}
+    }
+  }
+
   const defaultMonitorTriggerPolicy = normalizeRunnerTriggerPolicy({}, { role: "monitor" });
   push(
     "bot_runner_default_monitor_trigger_policy",
@@ -15200,9 +15263,43 @@ export async function runSelftestRunnerScenarios(push, deps) {
         && String(capturedSourceMessageEnvelope.source_route_key || "") === "telegram-monitor-ryoai2-bot-2::project::telegram::monitor::dest::actor",
       `kind=${String(processed.kind || "(none)")} reply_to=${capturedReplyToMessageID} origin=${String(capturedSourceMessageEnvelope.source_origin || "(none)")} route=${String(capturedSourceMessageEnvelope.source_route_key || "(none)")}`,
     );
-  } catch (err) {
-    push("runner_delivery_accepts_archived_local_route_provenance", false, String(err?.message || err));
-  }
+  } catch (err) {
+    push("runner_delivery_accepts_archived_local_route_provenance", false, String(err?.message || err));
+  }
+
+  try {
+    const envelope = resolveRunnerDeliverySourceMessageEnvelope({
+      routeState: {
+        recent_local_inbound_receipts: {},
+        recent_local_inbound_envelopes: {},
+      },
+      persistedRequest: {},
+      selectedRecord: {
+        parsedArchive: {
+          kind: "telegram_message",
+          chatID: "-100123",
+          chatType: "supergroup",
+          body: "@RyoAI2_bot hi without local provenance",
+          messageID: 331,
+          sender: "human",
+          senderIsBot: false,
+          mentionUsernames: ["ryoai2_bot"],
+          sourceOrigin: "archive_reconstructed",
+          sourceRouteKey: "telegram-monitor-ryoai2-bot-2::project::telegram::monitor::dest::actor",
+          sourceBotUsername: "ryoai2_bot",
+        },
+      },
+      routeKey: "telegram-monitor-ryoai2-bot-2::project::telegram::monitor::dest::actor",
+      currentBotSelector: "ryoai2_bot",
+    });
+    push(
+      "runner_delivery_drops_archive_reconstructed_reply_anchor_before_delivery",
+      Object.keys(safeObject(envelope)).length === 0,
+      `origin=${String(safeObject(envelope).source_origin || "(none)")} message=${String(safeObject(envelope).message_id || "(none)")}`,
+    );
+  } catch (err) {
+    push("runner_delivery_drops_archive_reconstructed_reply_anchor_before_delivery", false, String(err?.message || err));
+  }
 
   try {
     const provenanceTempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "metheus-runner-provenance-selftest-"));

package/package.json

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