@openclawbrain/cli 0.4.2 → 0.4.4

package/README.md

@@ -1,29 +1,29 @@
 # @openclawbrain/cli
 
-`@openclawbrain/cli@0.4.2` is the repo's next operator CLI package surface for OpenClawBrain. The latest published CLI remains `0.4.1` until this repo state is shipped.
+`@openclawbrain/cli@0.4.4` is the published operator CLI package for OpenClawBrain.
 
 Primary public flow:
 
 ```bash
 openclaw plugins install @openclawbrain/openclaw@0.4.0
-npx @openclawbrain/cli@0.4.2 install --openclaw-home ~/.openclaw
+npx @openclawbrain/cli@0.4.4 install --openclaw-home ~/.openclaw
 openclaw gateway restart
-npx @openclawbrain/cli@0.4.2 status --openclaw-home ~/.openclaw --detailed
+npx @openclawbrain/cli@0.4.4 status --openclaw-home ~/.openclaw --detailed
 ```
 
-Patch note for `0.4.2`: the CLI now persists declared attachment policy during install/attach so later `status` reads stop underreporting shared installs as `policy=null` / `undeclared`, and the package tarball now carries the full operator module surface plus traced-learning bridge needed for the canonical brain-store status path.
+Patch note for `0.4.4`: the CLI now normalizes `plugins.allow` / `plugins.entries.openclawbrain` correctly on reinstall and reports the canonical `openclawbrain` install identity in status output.
 
-Current caveat: some hosts still warn about a plugin id mismatch because the plugin manifest uses `openclawbrain` while the package/entry hint uses `openclaw`. The install still works; treat that warning as currently cosmetic.
+Host release note: patched OpenClaw host builds no longer emit the old `openclaw` vs `openclawbrain` mismatch warning. Older host builds may still show that warning until the host-side alias fix is released there.
 
 This package carries the `openclawbrain` CLI, daemon controls, import/export helpers, and install/status/operator management code. `@openclawbrain/openclaw` is the plugin/runtime payload.
 
 ## Commands
 
 ```bash
-npx @openclawbrain/cli@0.4.2 install --openclaw-home ~/.openclaw
-npx @openclawbrain/cli@0.4.2 status --openclaw-home ~/.openclaw --detailed
-npx @openclawbrain/cli@0.4.2 rollback --activation-root /var/openclawbrain/activation --dry-run
-npx @openclawbrain/cli@0.4.2 daemon status --activation-root /var/openclawbrain/activation
+npx @openclawbrain/cli@0.4.4 install --openclaw-home ~/.openclaw
+npx @openclawbrain/cli@0.4.4 status --openclaw-home ~/.openclaw --detailed
+npx @openclawbrain/cli@0.4.4 rollback --activation-root /var/openclawbrain/activation --dry-run
+npx @openclawbrain/cli@0.4.4 daemon status --activation-root /var/openclawbrain/activation
 ```
 
 If the CLI is already on your `PATH`, `openclawbrain ...` is the same command surface. The docs lead with `npx` because that is the clean-host public-registry lane that already passed on `redogfood`.

package/dist/src/cli.js

@@ -14,11 +14,12 @@ import { inspectActivationState, loadPackFromActivation, promoteCandidatePack, r
 import { resolveActivationRoot } from "./resolve-activation-root.js";
 import { describeOpenClawHomeInspection, discoverOpenClawHomes, formatOpenClawHomeLayout, formatOpenClawHomeProfileSource, inspectOpenClawHome } from "./openclaw-home-layout.js";
 import { inspectOpenClawBrainHookStatus, inspectOpenClawBrainPluginAllowlist } from "./openclaw-hook-truth.js";
-import { describeOpenClawBrainInstallIdentity, describeOpenClawBrainInstallLayout, findInstalledOpenClawBrainPlugin, getOpenClawBrainKnownPluginIds, pinInstalledOpenClawBrainPluginActivationRoot, resolveOpenClawBrainInstallTarget } from "./openclaw-plugin-install.js";
+import { describeOpenClawBrainInstallIdentity, describeOpenClawBrainInstallLayout, findInstalledOpenClawBrainPlugin, getOpenClawBrainKnownPluginIds, normalizeOpenClawBrainPluginsConfig, pinInstalledOpenClawBrainPluginActivationRoot, resolveOpenClawBrainInstallTarget } from "./openclaw-plugin-install.js";
 import { loadAttachmentPolicyDeclaration, resolveEffectiveAttachmentPolicyTruth, writeAttachmentPolicyDeclaration } from "./attachment-policy-truth.js";
 import { DEFAULT_WATCH_POLL_INTERVAL_SECONDS, buildNormalizedEventExportFromScannedEvents, bootstrapRuntimeAttach, buildOperatorSurfaceReport, clearOpenClawProfileRuntimeLoadProof, compileRuntimeContext, createAsyncTeacherLiveLoop, createOpenClawLocalSessionTail, createRuntimeEventExportScanner, describeCurrentProfileBrainStatus, formatOperatorRollbackReport, listOpenClawProfileRuntimeLoadProofs, loadRuntimeEventExportBundle, loadWatchTeacherSnapshotState, persistWatchTeacherSnapshot, rollbackRuntimeAttach, resolveAttachmentRuntimeLoadProofsPath, resolveOperatorTeacherSnapshotPath, resolveAsyncTeacherLiveLoopSnapshotPath, resolveWatchSessionTailCursorPath, resolveWatchStateRoot, resolveWatchTeacherSnapshotPath, scanLiveEventExport, scanRecordedSession, summarizeLearningPathFromMaterialization, summarizeNormalizedEventExportLabelFlow, writeScannedEventExportBundle } from "./index.js";
 import { appendLearningUpdateLogs } from "./learning-spine.js";
 import { buildPassiveLearningSessionExportFromOpenClawSessionStore } from "./local-session-passive-learning.js";
+import { summarizePackVectorEmbeddingState } from "./embedding-status.js";
 import { buildTracedLearningStatusSurface, loadBrainStoreTracedLearningBridge, mergeTracedLearningBridgePayload, persistBrainStoreTracedLearningBridge, writeTracedLearningBridge } from "./traced-learning-bridge.js";
 import { discoverOpenClawSessionStores, loadOpenClawSessionIndex, readOpenClawSessionFile } from "./session-store.js";
 import { readOpenClawBrainProviderDefaults, readOpenClawBrainProviderConfig, readOpenClawBrainProviderConfigFromSources, resolveOpenClawBrainProviderDefaultsPath } from "./provider-config.js";
@@ -953,11 +954,14 @@ function summarizeStatusEmbeddings(report, providerConfig) {
                 requireActivationReady: true
             });
             if (activePack !== null) {
-                totalEntryCount = activePack.vectors.entries.length;
-                embeddedEntryCount = activePack.vectors.entries.filter((entry) => entry.embedding !== undefined).length;
-                models = [...new Set(activePack.vectors.entries.flatMap((entry) => (entry.embedding === undefined ? [] : [entry.embedding.model])))].sort((left, right) => left.localeCompare(right));
-                liveState = embeddedEntryCount > 0 ? "yes" : "no";
-                liveDetail = `active pack stores ${embeddedEntryCount}/${totalEntryCount} numeric embeddings`;
+                const summary = summarizePackVectorEmbeddingState(activePack.vectors);
+                totalEntryCount = summary.vectorEntryCount;
+                embeddedEntryCount = summary.numericEmbeddingEntryCount;
+                models = summary.embeddingModels;
+                liveState = embeddedEntryCount === null ? "unknown" : embeddedEntryCount > 0 ? "yes" : "no";
+                liveDetail = embeddedEntryCount === null || totalEntryCount === null
+                    ? "active pack vector entries were unreadable during embedding inspection"
+                    : `active pack stores ${embeddedEntryCount}/${totalEntryCount} numeric embeddings`;
             }
         }
         catch (error) {
@@ -3577,46 +3581,42 @@ function readOpenClawJsonConfig(openclawHome) {
 function ensureOpenClawBrainPluginConfig(openclawHome) {
     const { path: openclawJsonPath, config } = readOpenClawJsonConfig(openclawHome);
     const selectedInstall = findInstalledOpenClawBrainPlugin(openclawHome).selectedInstall;
-    const knownPluginIds = selectedInstall === null
-        ? ["openclawbrain", "openclaw"]
-        : getOpenClawBrainKnownPluginIds(selectedInstall);
     const plugins = readJsonObjectRecord(config.plugins);
     if (plugins === null) {
         return {
             path: openclawJsonPath,
             changed: false,
-            detail: `Left ${shortenPath(openclawJsonPath)} unchanged because plugins.allow is not configured`
-        };
-    }
-    if (!Object.prototype.hasOwnProperty.call(plugins, "allow")) {
-        return {
-            path: openclawJsonPath,
-            changed: false,
-            detail: `Left ${shortenPath(openclawJsonPath)} unchanged because plugins.allow is not configured`
-        };
-    }
-    if (!Array.isArray(plugins.allow)) {
-        return {
-            path: openclawJsonPath,
-            changed: false,
-            detail: `Left ${shortenPath(openclawJsonPath)} unchanged because plugins.allow is not an array`
+            detail: `Left ${shortenPath(openclawJsonPath)} unchanged because plugins config is not configured`
         };
     }
-    const missingPluginIds = knownPluginIds.filter((pluginId) => !plugins.allow.includes(pluginId));
-    if (missingPluginIds.length === 0) {
+    const normalizedPlugins = normalizeOpenClawBrainPluginsConfig(plugins, selectedInstall);
+    if (!normalizedPlugins.changed) {
+        const details = [];
+        if (!Object.prototype.hasOwnProperty.call(plugins, "allow")) {
+            details.push("plugins.allow is not configured");
+        }
+        else if (!Array.isArray(plugins.allow)) {
+            details.push("plugins.allow is not an array");
+        }
+        else {
+            details.push(`plugins.allow already includes ${normalizedPlugins.allowedPluginIds.join(", ")}`);
+        }
+        const entries = readJsonObjectRecord(plugins.entries);
+        if (entries !== null && Object.prototype.hasOwnProperty.call(entries, normalizedPlugins.canonicalEntryId)) {
+            details.push(`plugins.entries already uses ${normalizedPlugins.canonicalEntryId}`);
+        }
         return {
             path: openclawJsonPath,
             changed: false,
-            detail: `Verified ${shortenPath(openclawJsonPath)} plugins.allow already includes ${knownPluginIds.join(", ")}`
+            detail: `Verified ${shortenPath(openclawJsonPath)} ${details.join("; ")}`
         };
     }
-    plugins.allow = [...plugins.allow, ...missingPluginIds];
-    config.plugins = plugins;
+    config.plugins = normalizedPlugins.pluginsConfig;
     writeFileSync(openclawJsonPath, `${JSON.stringify(config, null, 2)}\n`, "utf8");
     return {
         path: openclawJsonPath,
         changed: true,
-        detail: `Repaired ${shortenPath(openclawJsonPath)} plugins.allow by adding ${missingPluginIds.join(", ")}`
+        detail: `Repaired ${shortenPath(openclawJsonPath)} by ${normalizedPlugins.changes.join("; ")}`
     };
 }
 function scrubOpenClawBrainPluginConfig(openclawHome) {
@@ -4544,19 +4544,7 @@ function exportLocalSessionTailChangesToScanRoot(input) {
     };
 }
 function summarizeVectorEmbeddingState(vectors) {
-    if (vectors === null || vectors === undefined) {
-        return {
-            vectorEntryCount: null,
-            numericEmbeddingEntryCount: null,
-            embeddingModels: []
-        };
-    }
-    const embeddingModels = [...new Set(vectors.entries.flatMap((entry) => (entry.embedding === undefined ? [] : [entry.embedding.model])))].sort((left, right) => left.localeCompare(right));
-    return {
-        vectorEntryCount: vectors.entries.length,
-        numericEmbeddingEntryCount: vectors.entries.filter((entry) => entry.embedding !== undefined).length,
-        embeddingModels
-    };
+    return summarizePackVectorEmbeddingState(vectors);
 }
 function buildWatchEmbedTracePoint(input) {
     const summary = summarizeVectorEmbeddingState(input.vectors);

package/dist/src/embedding-status.js

@@ -0,0 +1,78 @@
+function isNumericArray(value) {
+    return Array.isArray(value) &&
+        value.length > 0 &&
+        value.every((entry) => typeof entry === "number" && Number.isFinite(entry));
+}
+
+function isNumericTypedArray(value) {
+    return ArrayBuffer.isView(value) &&
+        !(value instanceof DataView) &&
+        typeof value.length === "number" &&
+        value.length > 0 &&
+        Array.from(value).every((entry) => typeof entry === "number" && Number.isFinite(entry));
+}
+
+function hasNumericValues(value) {
+    return isNumericArray(value) || isNumericTypedArray(value);
+}
+
+function normalizeOptionalString(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+
+function extractNumericEmbeddingShape(entry) {
+    const embedding = entry?.embedding;
+    const candidates = [
+        embedding,
+        embedding?.values,
+        embedding?.vector,
+        embedding?.embedding,
+        entry?.values,
+        entry?.vector,
+        entry?.numericEmbedding,
+        entry?.numericEmbeddingValues,
+    ];
+    return candidates.find((candidate) => hasNumericValues(candidate)) ?? null;
+}
+
+function extractEmbeddingModel(entry) {
+    const candidates = [
+        entry?.embedding?.model,
+        entry?.embeddingModel,
+        entry?.model,
+    ];
+    for (const candidate of candidates) {
+        const normalized = normalizeOptionalString(candidate);
+        if (normalized !== null) {
+            return normalized;
+        }
+    }
+    return null;
+}
+
+export function summarizePackVectorEmbeddingState(vectors) {
+    if (!vectors || !Array.isArray(vectors.entries)) {
+        return {
+            vectorEntryCount: null,
+            numericEmbeddingEntryCount: null,
+            embeddingModels: []
+        };
+    }
+    const embeddingModels = [...new Set(vectors.entries
+            .flatMap((entry) => {
+            if (extractNumericEmbeddingShape(entry) === null) {
+                return [];
+            }
+            const model = extractEmbeddingModel(entry);
+            return model === null ? [] : [model];
+        }))].sort((left, right) => left.localeCompare(right));
+    return {
+        vectorEntryCount: vectors.entries.length,
+        numericEmbeddingEntryCount: vectors.entries.filter((entry) => extractNumericEmbeddingShape(entry) !== null).length,
+        embeddingModels
+    };
+}

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/package.json

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