@openclawbrain/cli 0.4.31 → 0.4.33

package/dist/src/cli.js

@@ -1738,6 +1738,19 @@ function readInstallRuntimeFingerprint(openclawHome) {
 function runOpenClawBrainConvergePluginStep(openclawHome) {
     const before = readInstallRuntimeFingerprint(openclawHome);
     const plan = planOpenClawBrainConvergePluginAction(before);
+    if (plan.action === "noop") {
+        return {
+            plan,
+            command: null,
+            changed: false,
+            changeReasons: [],
+            detail: "Skipped the OpenClaw plugin manager because the authoritative split-package plugin is already present and a no-op refresh would only churn volatile install metadata.",
+            warning: null,
+            capture: null,
+            before,
+            after: before
+        };
+    }
     let uninstallCapture = null;
     if (plan.action === "install" && shouldReplaceOpenClawBrainInstallBeforeConverge(before)) {
         uninstallCapture = runCapturedExternalCommand("openclaw", ["plugins", "uninstall", plan.pluginId]);
@@ -4761,13 +4774,13 @@ function resolveServeTimeLearningRuntimeInput(activationRoot, normalizedEventExp
         : readHistoricalServeTimeDecisions(logPath, collectServeTimeDecisionRecoveryTargets(normalizedEventExport));
     const serveTimeDecisions = mergeHistoricalServeTimeDecisions(historicalRecovery.decisions, boundedServeTimeDecisions);
     const decisionLogCount = serveTimeDecisions.length;
-    const pgVersion = decisionLogCount > 0 ? "v2" : "v1";
+    const pgVersion = "v2";
     const resolvedFallbackReason = combineServeTimeLearningFallbackReasons(fallbackReason, historicalRecovery.scanFailed ? "historical_recovery_scan_failed" : null);
     return {
         pgVersion,
         serveTimeDecisions,
         decisionLogCount,
-        baselineState: pgVersion === "v2" ? loadOrInitBaseline(activationRoot) : undefined,
+        baselineState: loadOrInitBaseline(activationRoot),
         fallbackReason: resolvedFallbackReason === null ? null : `serve_time_decision_log_${resolvedFallbackReason}`
     };
 }

package/dist/src/install-converge.js

@@ -103,10 +103,10 @@ export function planOpenClawBrainConvergePluginAction(fingerprint) {
     };
   }
   return {
-    action: "update",
+    action: "noop",
     packageSpec: "@openclawbrain/openclaw",
     pluginId: "openclawbrain",
-    reason: "refresh the existing split-package plugin install so install/upgrade/repair stays on one converge path",
+    reason: "the authoritative split-package plugin is already installed, so converge should preserve the current plugin-manager record instead of rewriting volatile install metadata",
   };
 }
 

package/dist/src/proof-command.js

@@ -384,11 +384,15 @@ function buildCoverageSnapshot({ attachedSetLine, runtimeLoadProofSnapshot, open
         profiles
     };
 }
-function buildHardeningSnapshot({ attachTruthLine, serveLine, routeFnLine, surfaceLine, verdict, statusSignals }) {
+function buildHardeningSnapshot({ attachTruthLine, serveLine, routeFnLine, surfaceLine, brainLine, routeLine, learningLine, learningPathLine, verdict, statusSignals }) {
     const attachTruth = extractKeyValuePairs(attachTruthLine);
     const serve = extractKeyValuePairs(serveLine);
     const routeFn = extractKeyValuePairs(routeFnLine);
     const surface = extractKeyValuePairs(surfaceLine);
+    const brain = extractKeyValuePairs(brainLine);
+    const route = extractKeyValuePairs(routeLine);
+    const learning = extractKeyValuePairs(learningLine);
+    const learningPath = extractKeyValuePairs(learningPathLine);
     return {
         contract: "openclaw_operator_hardening_snapshot.v1",
         generatedAt: new Date().toISOString(),
@@ -427,6 +431,27 @@ function buildHardeningSnapshot({ attachTruthLine, serveLine, routeFnLine, surfa
             available: routeFn.available ?? null,
             freshness: routeFn.freshness ?? null,
         },
+        routeLayer: {
+            activePackId: brain.pack ?? null,
+            routerIdentity: brain.router ?? route.router ?? null,
+            routeFreshness: brain.routeFreshness ?? null,
+            routeFingerprint: route.freshness ?? null,
+            lastPromotionAt: brain.lastPromotion ?? null,
+            brainState: brain.state ?? null,
+            initMode: brain.init ?? null,
+            serveState: serve.state ?? null,
+            usedLearnedRouteFn: serve.usedRouteFn ?? null,
+            routeFnAvailable: routeFn.available ?? null,
+            routeFnFreshness: routeFn.freshness ?? null,
+            learningState: learning.state ?? null,
+            learningMode: learning.mode ?? null,
+            learningPathSource: learningPath.source ?? null,
+            learningPathPg: learningPath.pg ?? null,
+            learningPathMethod: learningPath.method ?? null,
+            learningPathTarget: learningPath.target ?? null,
+            learningPathConnect: learningPath.connect ?? null,
+            learningPathTrajectories: learningPath.trajectories ?? null,
+        },
         verdict: {
             verdict: verdict.verdict,
             severity: verdict.severity,
@@ -576,7 +601,7 @@ function buildVerdict({ steps, gatewayStatus, pluginInspect, statusSignals, brea
     };
 }
 
-function buildSummary({ options, steps, verdict, gatewayStatusText, pluginInspectText, statusSignals, breadcrumbs, runtimeLoadProofSnapshot, surfaceLine, surfacesLine, surfaceNoteLine, hotfixLine, guardLine, feedbackLine, attributionLine, attributionCoverageLine, learningPathLine, learningFlowLine, learningHealthLine, coverageSnapshot, hardeningSnapshot }) {
+function buildSummary({ options, steps, verdict, gatewayStatusText, pluginInspectText, statusSignals, breadcrumbs, runtimeLoadProofSnapshot, surfaceLine, surfacesLine, surfaceNoteLine, hotfixLine, guardLine, brainLine, routeLine, learningLine, feedbackLine, attributionLine, attributionCoverageLine, learningPathLine, learningFlowLine, learningHealthLine, coverageSnapshot, hardeningSnapshot }) {
     const passed = [];
     const missing = [];
     const warnings = Array.isArray(verdict.warnings) ? verdict.warnings : [];
@@ -660,6 +685,21 @@ function buildSummary({ options, steps, verdict, gatewayStatusText, pluginInspec
             ? ["- runtime guard line not reported by detailed status"]
             : [`- ${guardLine}`]),
         "",
+        "## Route Layer Truth",
+        ...(brainLine === null
+            ? ["- brain line not reported by detailed status"]
+            : [`- ${brainLine}`]),
+        ...(routeLine === null
+            ? ["- route line not reported by detailed status"]
+            : [`- ${routeLine}`]),
+        ...(learningLine === null
+            ? ["- learning line not reported by detailed status"]
+            : [`- ${learningLine}`]),
+        ...(learningPathLine === null
+            ? ["- path line not reported by detailed status"]
+            : [`- ${learningPathLine}`]),
+        `- derived: activePack=${hardeningSnapshot.routeLayer.activePackId ?? "none"} router=${hardeningSnapshot.routeLayer.routerIdentity ?? "none"} routeFreshness=${hardeningSnapshot.routeLayer.routeFreshness ?? "none"} routeFingerprint=${hardeningSnapshot.routeLayer.routeFingerprint ?? "none"} usedLearnedRouteFn=${hardeningSnapshot.routeLayer.usedLearnedRouteFn ?? "none"}`,
+        "",
         "## Learning Flow",
         ...(learningPathLine === null
             ? ["- learning path line not reported by detailed status"]
@@ -988,6 +1028,9 @@ export function captureOperatorProofBundle(options) {
     const serveLine = extractDetailedStatusLine(statusCapture.stdout, "serve");
     const routeFnLine = extractDetailedStatusLine(statusCapture.stdout, "routeFn");
     const guardLine = extractDetailedStatusLine(statusCapture.stdout, "guard");
+    const brainLine = extractDetailedStatusLine(statusCapture.stdout, "brain");
+    const routeLine = extractDetailedStatusLine(statusCapture.stdout, "route");
+    const learningLine = extractDetailedStatusLine(statusCapture.stdout, "learning");
     const learningFlowLine = extractDetailedStatusLine(statusCapture.stdout, "learnFlow");
     const learningHealthLine = extractDetailedStatusLine(statusCapture.stdout, "health");
     const feedbackLine = extractDetailedStatusLine(statusCapture.stdout, "feedback");
@@ -1024,6 +1067,10 @@ export function captureOperatorProofBundle(options) {
         serveLine,
         routeFnLine,
         surfaceLine,
+        brainLine,
+        routeLine,
+        learningLine,
+        learningPathLine,
         verdict,
         statusSignals,
     });
@@ -1053,6 +1100,9 @@ export function captureOperatorProofBundle(options) {
         surfaceNoteLine,
         hotfixLine,
         guardLine,
+        brainLine,
+        routeLine,
+        learningLine,
         learningFlowLine,
         learningHealthLine,
         feedbackLine,
@@ -1075,6 +1125,9 @@ export function captureOperatorProofBundle(options) {
         surfaceNoteLine,
         hotfixLine,
         guardLine,
+        brainLine,
+        routeLine,
+        learningLine,
         learningFlowLine,
         learningHealthLine,
         feedbackLine,

package/dist/src/shadow-extension-proof.js

@@ -3,6 +3,7 @@ import { homedir } from "node:os";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
 import { describeOpenClawBrainInstallLayout, findInstalledOpenClawBrainPlugin } from "./openclaw-plugin-install.js";
+import { inspectOpenClawBrainHookStatus } from "./openclaw-hook-truth.js";
 const REQUIRED_RUNTIME_GUARD_EXPORTS = [
     "createBeforePromptBuildHandler",
     "isActivationRootPlaceholder",
@@ -70,6 +71,10 @@ export function inspectInstalledOpenClawBrainExtension(openclawHome, extensionId
 }
 export async function proveInstalledOpenClawBrainExtensionLoad(openclawHome, extensionId = "openclawbrain") {
     const inspected = inspectInstalledOpenClawBrainExtension(openclawHome, extensionId);
+    const hookStatus = inspectOpenClawBrainHookStatus(openclawHome);
+    if (hookStatus.loadability !== "loadable") {
+        throw new Error(`[shadow-extension-load-proof] Installed hook is not loadable enough to prove its loader: ${hookStatus.detail}`);
+    }
     const runtimeGuardModule = await importWithHelpfulError(inspected.runtimeGuardPath, `runtime-guard.js (${describeOpenClawBrainInstallLayout(inspected.installLayout)})`);
     const runtimeGuardExportNames = Object.keys(runtimeGuardModule).sort((left, right) => left.localeCompare(right));
     const missingRuntimeGuardExports = REQUIRED_RUNTIME_GUARD_EXPORTS.filter((exportName) => !runtimeGuardExportNames.includes(exportName));

package/dist/src/traced-learning-bridge.js

@@ -272,13 +272,15 @@ function loadJsonFile(pathname) {
 function resolveActivePackPaths(activationRoot) {
     const pointers = toRecord(loadJsonFile(path.join(path.resolve(activationRoot), "activation-pointers.json")));
     const active = toRecord(pointers?.active);
+    const packId = normalizeOptionalString(active?.packId);
     const packRootDir = normalizeOptionalString(active?.packRootDir)
-        ?? (normalizeOptionalString(active?.packId) === null
+        ?? (packId === null
             ? null
-            : path.join(path.resolve(activationRoot), "packs", String(active.packId)));
+            : path.join(path.resolve(activationRoot), "packs", String(packId)));
     const manifestPath = normalizeOptionalString(active?.manifestPath)
         ?? (packRootDir === null ? null : path.join(packRootDir, "manifest.json"));
     return {
+        packId,
         packRootDir,
         manifestPath
     };
@@ -376,6 +378,38 @@ function buildWatchSnapshotAttributionCoverage(activationRoot) {
         detail: `watch sparse-feedback queue: completed_without_evaluation=0, ready=${normalizeCount(readyCount)}, delayed=${normalizeCount(delayedCount)}, budget_deferred=${normalizeCount(budgetDeferredCount)}`
     };
 }
+function readWatchTeacherSnapshotPackTruth(activationRoot) {
+    const snapshot = toRecord(loadJsonFile(path.join(path.resolve(activationRoot), "watch", "teacher-snapshot.json")));
+    const learning = toRecord(snapshot?.learning);
+    const nestedSnapshot = toRecord(snapshot?.snapshot);
+    const nestedLearning = toRecord(nestedSnapshot?.learning);
+    return {
+        lastHandledMaterializationPackId: normalizeOptionalString(snapshot?.lastHandledMaterializationPackId)
+            ?? normalizeOptionalString(learning?.lastHandledMaterializationPackId)
+            ?? normalizeOptionalString(nestedLearning?.lastHandledMaterializationPackId),
+        lastMaterializationPackId: normalizeOptionalString(snapshot?.lastMaterializationPackId)
+            ?? normalizeOptionalString(learning?.lastMaterializationPackId)
+            ?? normalizeOptionalString(nestedLearning?.lastMaterializationPackId)
+    };
+}
+function buildActivationPackTruth(activationRoot) {
+    const active = resolveActivePackPaths(activationRoot);
+    const activePackId = active.packId;
+    if (activePackId === null) {
+        return null;
+    }
+    const watchTruth = readWatchTeacherSnapshotPackTruth(activationRoot);
+    const handledPackId = watchTruth.lastHandledMaterializationPackId ?? watchTruth.lastMaterializationPackId;
+    if (handledPackId === null) {
+        return null;
+    }
+    return {
+        activePackId,
+        handledPackId,
+        materializedPackId: handledPackId,
+        promoted: handledPackId === activePackId
+    };
+}
 function shouldPreferActivationFeedbackSummary(current, fallback) {
     if (fallback === null) {
         return false;
@@ -407,18 +441,35 @@ function shouldPreferWatchAttributionCoverage(current, fallback) {
 function enrichBridgeWithActivationTruth(activationRoot, bridge) {
     const feedbackSummary = buildActivePackFeedbackSummary(activationRoot);
     const attributionCoverage = buildWatchSnapshotAttributionCoverage(activationRoot);
-    if (!shouldPreferActivationFeedbackSummary(bridge.feedbackSummary, feedbackSummary)
-        && !shouldPreferWatchAttributionCoverage(bridge.attributionCoverage, attributionCoverage)) {
+    const packTruth = buildActivationPackTruth(activationRoot);
+    const preferFeedbackSummary = shouldPreferActivationFeedbackSummary(bridge.feedbackSummary, feedbackSummary);
+    const preferAttributionCoverage = shouldPreferWatchAttributionCoverage(bridge.attributionCoverage, attributionCoverage);
+    const preferPackTruth = packTruth !== null
+        && (bridge.materializedPackId === null || (bridge.promoted !== true && packTruth.promoted === true))
+        && (packTruth.promoted === true || bridge.materializedPackId === null);
+    if (!preferFeedbackSummary && !preferAttributionCoverage && !preferPackTruth) {
         return bridge;
     }
     return normalizeBridgePayload({
         ...bridge,
-        feedbackSummary: shouldPreferActivationFeedbackSummary(bridge.feedbackSummary, feedbackSummary)
+        materializedPackId: preferPackTruth ? packTruth.materializedPackId : bridge.materializedPackId,
+        promoted: preferPackTruth ? packTruth.promoted : bridge.promoted,
+        feedbackSummary: preferFeedbackSummary
             ? feedbackSummary
             : bridge.feedbackSummary,
-        attributionCoverage: shouldPreferWatchAttributionCoverage(bridge.attributionCoverage, attributionCoverage)
+        attributionCoverage: preferAttributionCoverage
             ? attributionCoverage
-            : bridge.attributionCoverage
+            : bridge.attributionCoverage,
+        source: preferPackTruth
+            ? {
+                ...(bridge.source ?? {}),
+                activationPackTruth: {
+                    activePackId: packTruth.activePackId,
+                    handledPackId: packTruth.handledPackId,
+                    source: "active_pack_plus_watch_snapshot"
+                }
+            }
+            : bridge.source
     });
 }
 function normalizeLastInterruptionSummary(value) {
@@ -865,6 +916,21 @@ export function persistBrainStoreTracedLearningBridge(payload, options = {}) {
     try {
         db = new sqlite.DatabaseSync(dbPath);
         const summary = normalizePersistedStatusSurface(payload);
+        const existingSummaryLoaded = loadTrainingStateJson(db, TRACED_LEARNING_STATUS_SURFACE_STATE_KEY);
+        if (existingSummaryLoaded.value !== null) {
+            const existingSummary = normalizePersistedStatusSurface(existingSummaryLoaded.value);
+            if (JSON.stringify(existingSummary) === JSON.stringify(summary)) {
+                return {
+                    path: dbPath,
+                    bridge: buildPersistedStatusSurfaceBridge(existingSummary, {
+                        brainRoot,
+                        dbPath
+                    }),
+                    persisted: false,
+                    error: null
+                };
+            }
+        }
         writeTrainingStateJson(db, TRACED_LEARNING_STATUS_SURFACE_STATE_KEY, summary);
         return {
             path: dbPath,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclawbrain/cli",
-  "version": "0.4.31",
+  "version": "0.4.33",
   "description": "OpenClawBrain operator CLI package with install/status helpers, daemon controls, and import/export tooling.",
   "type": "module",
   "main": "./dist/src/index.js",