@openclawbrain/cli 0.4.3 → 0.4.5

package/dist/src/openclaw-hook-truth.js

@@ -1,6 +1,6 @@
 import { readFileSync } from "node:fs";
 import path from "node:path";
-import { describeOpenClawBrainInstallIdentity, describeOpenClawBrainInstallLayout, findInstalledOpenClawBrainPlugin, getOpenClawBrainKnownPluginIds } from "./openclaw-plugin-install.js";
+import { describeOpenClawBrainInstallIdentity, describeOpenClawBrainInstallLayout, findInstalledOpenClawBrainPlugin, getOpenClawBrainAllowedPluginIds } from "./openclaw-plugin-install.js";
 function toErrorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -77,7 +77,7 @@ function describeAdditionalInstallDetail(additionalInstalls) {
 export function inspectOpenClawBrainPluginAllowlist(openclawHome) {
     const { path: openclawJsonPath, config } = readOpenClawJsonConfig(openclawHome);
     const installedPlugin = findInstalledOpenClawBrainPlugin(openclawHome);
-    const knownPluginIds = getOpenClawBrainKnownPluginIds(installedPlugin.selectedInstall);
+    const allowedPluginIds = getOpenClawBrainAllowedPluginIds(installedPlugin.selectedInstall);
     const plugins = readJsonObjectRecord(config.plugins);
     if (plugins === null) {
         return {
@@ -97,15 +97,15 @@ export function inspectOpenClawBrainPluginAllowlist(openclawHome) {
             detail: `${shortenPath(openclawJsonPath)} has a non-array plugins.allow value, so OpenClawBrain load cannot be proven from config`
         };
     }
-    const matchedPluginId = knownPluginIds.find((pluginId) => plugins.allow.includes(pluginId)) ?? null;
+    const matchedPluginId = allowedPluginIds.find((pluginId) => plugins.allow.includes(pluginId)) ?? null;
     return matchedPluginId !== null
         ? {
             state: "allowed",
-            detail: `${shortenPath(openclawJsonPath)} plugins.allow explicitly includes ${matchedPluginId}; recognized OpenClawBrain ids are ${knownPluginIds.join(", ")}`
+            detail: `${shortenPath(openclawJsonPath)} plugins.allow explicitly includes ${matchedPluginId}; recognized OpenClawBrain ids are ${allowedPluginIds.join(", ")}`
         }
         : {
             state: "blocked",
-            detail: `${shortenPath(openclawJsonPath)} plugins.allow excludes recognized OpenClawBrain ids ${knownPluginIds.join(", ")}`
+            detail: `${shortenPath(openclawJsonPath)} plugins.allow excludes recognized OpenClawBrain ids ${allowedPluginIds.join(", ")}`
         };
 }
 export function inspectOpenClawBrainHookStatus(openclawHome) {

package/dist/src/openclaw-plugin-install.d.ts

@@ -32,7 +32,15 @@ export declare const OPENCLAWBRAIN_SHADOW_PACKAGE_NAME = "openclawbrain";
 export declare const OPENCLAWBRAIN_NATIVE_PACKAGE_NAME = "@openclawbrain/openclaw";
 export declare const OPENCLAWBRAIN_NATIVE_INSTALL_ID = "openclaw";
 export declare function describeOpenClawBrainInstallLayout(installLayout: OpenClawBrainInstallLayout): string;
+export declare function getOpenClawBrainAllowedPluginIds(install: OpenClawBrainInstalledPlugin | null | undefined): string[];
 export declare function getOpenClawBrainKnownPluginIds(install: OpenClawBrainInstalledPlugin | null | undefined): string[];
+export declare function normalizeOpenClawBrainPluginsConfig(pluginsConfig: Record<string, unknown>, install: OpenClawBrainInstalledPlugin | null | undefined): {
+    changed: boolean;
+    pluginsConfig: Record<string, unknown>;
+    changes: string[];
+    allowedPluginIds: string[];
+    canonicalEntryId: string;
+};
 export declare function describeOpenClawBrainInstallIdentity(install: OpenClawBrainInstalledPlugin): string;
 export declare function findInstalledOpenClawBrainPlugin(openclawHome: string, pluginId?: string): OpenClawBrainInstalledPluginLookup;
 export declare function resolveOpenClawBrainInstallTarget(openclawHome: string): OpenClawBrainInstallTarget;

package/dist/src/openclaw-plugin-install.js

@@ -46,6 +46,19 @@ function normalizeOptionalString(value) {
     const trimmed = value.trim();
     return trimmed.length > 0 ? trimmed : null;
 }
+function readJsonObjectRecord(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    return value;
+}
+function pushUniqueNormalizedId(ids, value) {
+    const normalized = normalizeOptionalString(value);
+    if (normalized === null || ids.includes(normalized)) {
+        return;
+    }
+    ids.push(normalized);
+}
 function normalizeInstallId(value) {
     const normalized = normalizeOptionalString(value);
     if (normalized === null) {
@@ -179,27 +192,116 @@ export function describeOpenClawBrainInstallLayout(installLayout) {
         ? "native package plugin"
         : "generated shadow extension";
 }
-export function getOpenClawBrainKnownPluginIds(install) {
+export function getOpenClawBrainAllowedPluginIds(install) {
     const ids = [];
-    const push = (value) => {
-        const normalized = normalizeOptionalString(value);
-        if (normalized === null || ids.includes(normalized)) {
-            return;
-        }
-        ids.push(normalized);
-    };
-    push(OPENCLAWBRAIN_PLUGIN_ID);
-    push(install?.manifestId ?? null);
-    push(install?.installId ?? null);
+    pushUniqueNormalizedId(ids, OPENCLAWBRAIN_PLUGIN_ID);
+    pushUniqueNormalizedId(ids, install?.manifestId ?? null);
+    return ids;
+}
+function getOpenClawBrainLegacyInstallHintIds(install) {
+    const ids = [];
+    pushUniqueNormalizedId(ids, install?.installId ?? null);
     if (install?.packageName === OPENCLAWBRAIN_NATIVE_PACKAGE_NAME) {
-        push(OPENCLAWBRAIN_NATIVE_INSTALL_ID);
+        pushUniqueNormalizedId(ids, OPENCLAWBRAIN_NATIVE_INSTALL_ID);
     }
-    return ids;
+    return ids.filter((id) => !getOpenClawBrainAllowedPluginIds(install).includes(id));
+}
+export function getOpenClawBrainKnownPluginIds(install) {
+    return [
+        ...getOpenClawBrainAllowedPluginIds(install),
+        ...getOpenClawBrainLegacyInstallHintIds(install)
+    ];
+}
+function mergePluginEntryValues(preferredValue, fallbackValue) {
+    if (preferredValue === undefined) {
+        return fallbackValue;
+    }
+    if (fallbackValue === undefined) {
+        return preferredValue;
+    }
+    const preferredRecord = readJsonObjectRecord(preferredValue);
+    const fallbackRecord = readJsonObjectRecord(fallbackValue);
+    if (preferredRecord === null || fallbackRecord === null) {
+        return preferredValue;
+    }
+    const mergedValue = {
+        ...fallbackRecord,
+        ...preferredRecord
+    };
+    const preferredConfig = readJsonObjectRecord(preferredRecord.config);
+    const fallbackConfig = readJsonObjectRecord(fallbackRecord.config);
+    if (preferredConfig !== null || fallbackConfig !== null) {
+        mergedValue.config = {
+            ...(fallbackConfig ?? {}),
+            ...(preferredConfig ?? {})
+        };
+    }
+    return mergedValue;
+}
+export function normalizeOpenClawBrainPluginsConfig(pluginsConfig, install) {
+    const nextPluginsConfig = {
+        ...pluginsConfig
+    };
+    const changes = [];
+    let changed = false;
+    const allowedPluginIds = getOpenClawBrainAllowedPluginIds(install);
+    const legacyInstallHintIds = getOpenClawBrainLegacyInstallHintIds(install);
+    if (Array.isArray(nextPluginsConfig.allow)) {
+        const removedAllowEntries = nextPluginsConfig.allow.filter((entry) => legacyInstallHintIds.includes(entry));
+        const filteredAllow = nextPluginsConfig.allow.filter((entry) => !legacyInstallHintIds.includes(entry));
+        const addedAllowEntries = allowedPluginIds.filter((pluginId) => !filteredAllow.includes(pluginId));
+        if (removedAllowEntries.length > 0 || addedAllowEntries.length > 0) {
+            nextPluginsConfig.allow = [...filteredAllow, ...addedAllowEntries];
+            changed = true;
+            if (removedAllowEntries.length > 0) {
+                changes.push(`removed plugins.allow entries ${removedAllowEntries.join(", ")}`);
+            }
+            if (addedAllowEntries.length > 0) {
+                changes.push(`added plugins.allow entries ${addedAllowEntries.join(", ")}`);
+            }
+        }
+    }
+    const canonicalEntryId = allowedPluginIds[0] ?? OPENCLAWBRAIN_PLUGIN_ID;
+    const entries = readJsonObjectRecord(nextPluginsConfig.entries);
+    if (entries !== null) {
+        const legacyEntryIds = legacyInstallHintIds.filter((entryId) => Object.prototype.hasOwnProperty.call(entries, entryId));
+        if (legacyEntryIds.length > 0) {
+            const nextEntries = {
+                ...entries
+            };
+            let mergedEntryValue = Object.prototype.hasOwnProperty.call(nextEntries, canonicalEntryId)
+                ? nextEntries[canonicalEntryId]
+                : undefined;
+            for (const entryId of legacyEntryIds) {
+                mergedEntryValue = mergePluginEntryValues(mergedEntryValue, nextEntries[entryId]);
+            }
+            nextEntries[canonicalEntryId] = mergedEntryValue;
+            for (const entryId of legacyEntryIds) {
+                if (entryId === canonicalEntryId) {
+                    continue;
+                }
+                delete nextEntries[entryId];
+            }
+            nextPluginsConfig.entries = nextEntries;
+            changed = true;
+            changes.push(`${Object.prototype.hasOwnProperty.call(entries, canonicalEntryId) ? "merged" : "moved"} plugins.entries.${legacyEntryIds.join(", plugins.entries.")} to plugins.entries.${canonicalEntryId}`);
+        }
+    }
+    return {
+        changed,
+        pluginsConfig: nextPluginsConfig,
+        changes,
+        allowedPluginIds,
+        canonicalEntryId
+    };
 }
 export function describeOpenClawBrainInstallIdentity(install) {
+    const displayInstallId = install.packageName === OPENCLAWBRAIN_NATIVE_PACKAGE_NAME
+        ? OPENCLAWBRAIN_PLUGIN_ID
+        : install.installId ?? path.basename(install.extensionDir);
     return [
         `manifest=${install.manifestId ?? OPENCLAWBRAIN_PLUGIN_ID}`,
-        `install=${install.installId ?? path.basename(install.extensionDir)}`,
+        `install=${displayInstallId}`,
         `package=${install.packageName ?? "unknown"}`
     ].join(" ");
 }

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

@@ -132,6 +132,48 @@ function loadTrainingStateJson(db, key) {
 function writeTrainingStateJson(db, key, value) {
     db.prepare(`INSERT OR REPLACE INTO brain_training_state (key, value) VALUES (?, ?)`).run(key, JSON.stringify(value));
 }
+function buildTracedLearningRoutingBuildFromServeTime(serveTimeLearning) {
+    return {
+        learnedRoutingPath: serveTimeLearning.pgVersion === "v2" ? "policy_gradient_v2" : "policy_gradient_v1",
+        pgVersionRequested: serveTimeLearning.pgVersion,
+        pgVersionUsed: serveTimeLearning.pgVersion,
+        decisionLogCount: normalizeCount(serveTimeLearning.decisionLogCount),
+        fallbackReason: serveTimeLearning.pgVersion === "v1"
+            ? normalizeOptionalString(serveTimeLearning.fallbackReason) ?? "no_serve_time_decisions"
+            : null,
+        updatedBaseline: null
+    };
+}
+export function buildTracedLearningBridgePayloadFromRuntime(input) {
+    const lastMaterialization = input?.lastMaterialization ?? null;
+    const serveTimeLearning = input?.serveTimeLearning ?? {
+        pgVersion: "v1",
+        decisionLogCount: 0,
+        fallbackReason: null
+    };
+    const learnedRouter = lastMaterialization?.candidate?.summary?.learnedRouter ?? null;
+    const routingBuild = lastMaterialization?.candidate?.routingBuild ?? buildTracedLearningRoutingBuildFromServeTime(serveTimeLearning);
+    const fallbackReason = routingBuild.fallbackReason ??
+        (routingBuild.pgVersionUsed === "v1"
+            ? normalizeOptionalString(serveTimeLearning.fallbackReason) ?? "no_serve_time_decisions"
+            : null);
+    return normalizeBridgePayload({
+        updatedAt: input?.updatedAt,
+        routeTraceCount: learnedRouter?.routeTraceCount ?? serveTimeLearning.decisionLogCount,
+        supervisionCount: learnedRouter?.supervisionCount ?? 0,
+        routerUpdateCount: learnedRouter?.updateCount ?? 0,
+        teacherArtifactCount: input?.teacherArtifactCount ?? 0,
+        pgVersionRequested: routingBuild.pgVersionRequested,
+        pgVersionUsed: routingBuild.pgVersionUsed,
+        decisionLogCount: routingBuild.decisionLogCount,
+        fallbackReason,
+        routerNoOpReason: learnedRouter?.noOpReason ?? null,
+        materializedPackId: input?.materializedPackId ?? lastMaterialization?.candidate?.summary?.packId ?? null,
+        promoted: input?.promoted === true,
+        baselinePersisted: input?.baselinePersisted === true,
+        source: input?.source
+    });
+}
 function countRows(db, tableName) {
     const row = db.prepare(`SELECT COUNT(*) as count FROM ${tableName}`).get();
     return normalizeCount(row?.count);
@@ -323,6 +365,12 @@ export function persistBrainStoreTracedLearningBridge(payload, options = {}) {
         }
     }
 }
+export function persistTracedLearningBridgeState(activationRoot, payload, options = {}) {
+    const bridge = mergeTracedLearningBridgePayload(payload, loadBrainStoreTracedLearningBridge(options));
+    persistBrainStoreTracedLearningBridge(bridge, options);
+    writeTracedLearningBridge(activationRoot, bridge);
+    return bridge;
+}
 export function loadBrainStoreTracedLearningBridge(options = {}) {
     const brainRoot = resolveBrainRoot(options.env ?? process.env);
     const dbPath = path.join(brainRoot, "state.db");

package/package.json

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