@openclawbrain/openclaw 0.3.5 → 0.3.6

package/dist/src/index.js

@@ -6148,7 +6148,7 @@ function buildOperatorFindings(report) {
         findings.push({ severity, code, summary, detail });
     };
     if (report.hook.desynced) {
-        push("fail", "hook_desynced", "profile hook is blocked by OpenClaw config desync", report.hook.detail);
+        push("fail", "hook_desynced", "profile hook is present but not loadable", report.hook.detail);
     }
     else if (report.attachmentTruth.state === "not_attached") {
         push("fail", "current_profile_not_attached", "current profile is not attached", report.attachmentTruth.detail);
@@ -6393,8 +6393,8 @@ function summarizeOperatorAttachmentTruth(report) {
             watchOnly: false,
             activationRoot: report.activationRoot,
             servingSlot: report.active === null ? "none" : "active",
-            detail: report.hook.installState === "blocked_by_allowlist"
-                ? "current profile hook files exist, but OpenClaw will not load them until the plugin allowlist/config desync is repaired"
+            detail: report.hook.loadability === "blocked"
+                ? "current profile hook files exist, but OpenClaw will not load them until the installed hook is repaired"
                 : "current profile hook is present on the selected OpenClaw home"
         };
     }
@@ -6421,7 +6421,7 @@ function summarizeCurrentProfileBrainSummary(input) {
         return "Brain is not attached to the current Profile.";
     }
     if (input.hookDesynced) {
-        return "Brain hook files exist, but OpenClaw config currently blocks them from loading.";
+        return "Brain hook files exist, but the installed hook is not loadable yet.";
     }
     if (input.attachmentState === "unknown") {
         return input.watchOnly
@@ -6603,9 +6603,16 @@ function buildCurrentProfileBrainStatusFromReport(report, policyMode, profileId)
             noun: "Hook",
             scope: report.hook.scope,
             openclawHome: report.hook.openclawHome,
+            extensionDir: report.hook.extensionDir,
             hookPath: report.hook.hookPath,
             runtimeGuardPath: report.hook.runtimeGuardPath,
             manifestPath: report.hook.manifestPath,
+            packageJsonPath: report.hook.packageJsonPath,
+            manifestId: report.hook.manifestId,
+            installId: report.hook.installId,
+            packageName: report.hook.packageName,
+            installLayout: report.hook.installLayout,
+            additionalInstallCount: report.hook.additionalInstallCount,
             installState: report.hook.installState,
             loadability: report.hook.loadability,
             loadProof: report.hook.loadProof,
@@ -6872,4 +6879,4 @@ export { buildPassiveLearningSessionExportFromOpenClawSessionStore, buildPassive
 export { DEFAULT_OLLAMA_BASE_URL, DEFAULT_OLLAMA_TIMEOUT_MS, OllamaClient, OllamaClientError, createOllamaClient } from "./ollama-client.js";
 export { resolveActivationRoot } from "./resolve-activation-root.js";
 export { runDaemonCommand, parseDaemonArgs } from "./daemon.js";
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/src/openclaw-hook-truth.d.ts

@@ -1,3 +1,4 @@
+import { type OpenClawBrainInstallLayout } from "./openclaw-plugin-install.js";
 export type OpenClawBrainHookInstallState = "installed" | "not_installed" | "blocked_by_allowlist" | "unverified";
 export type OpenClawBrainHookLoadability = "loadable" | "blocked" | "not_installed" | "unverified";
 export type OpenClawBrainHookLoadProof = "status_probe_ready" | "not_ready";
@@ -5,9 +6,16 @@ export type OpenClawBrainPluginAllowlistState = "unrestricted" | "allowed" | "bl
 export interface OpenClawBrainHookInspection {
     scope: "exact_openclaw_home" | "activation_root_only";
     openclawHome: string | null;
+    extensionDir: string | null;
     hookPath: string | null;
     runtimeGuardPath: string | null;
     manifestPath: string | null;
+    packageJsonPath: string | null;
+    manifestId: string | null;
+    installId: string | null;
+    packageName: string | null;
+    installLayout: OpenClawBrainInstallLayout | null;
+    additionalInstallCount: number;
     installState: OpenClawBrainHookInstallState;
     loadability: OpenClawBrainHookLoadability;
     pluginAllowlistState: OpenClawBrainPluginAllowlistState;

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

@@ -1,5 +1,6 @@
-import { existsSync, readFileSync } from "node:fs";
+import { readFileSync } from "node:fs";
 import path from "node:path";
+import { describeOpenClawBrainInstallIdentity, describeOpenClawBrainInstallLayout, findInstalledOpenClawBrainPlugin, getOpenClawBrainKnownPluginIds } from "./openclaw-plugin-install.js";
 function toErrorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -34,8 +35,49 @@ function shortenPath(fullPath) {
     }
     return fullPath;
 }
+function inspectInstalledHookActivationRoot(loaderEntryPath) {
+    let content;
+    try {
+        content = readFileSync(loaderEntryPath, "utf8");
+    }
+    catch (error) {
+        return {
+            ready: false,
+            detail: `installed loader entry ${shortenPath(loaderEntryPath)} could not be read: ${toErrorMessage(error)}`
+        };
+    }
+    const match = content.match(/const\s+ACTIVATION_ROOT\s*=\s*["'`]([^"'`]+)["'`]/) ??
+        content.match(/activationRoot:\s*["'`]([^"'`]+)["'`]/);
+    if (!match || !match[1]) {
+        return {
+            ready: false,
+            detail: `installed loader entry ${shortenPath(loaderEntryPath)} does not declare a pinned activation root`
+        };
+    }
+    const activationRoot = match[1].trim();
+    if (activationRoot === "__ACTIVATION_ROOT__" || activationRoot === "__ACTIVATION_" + "ROOT__") {
+        return {
+            ready: false,
+            detail: `installed loader entry ${shortenPath(loaderEntryPath)} still contains the ACTIVATION_ROOT placeholder; rerun openclawbrain install/attach to pin the runtime hook`
+        };
+    }
+    return {
+        ready: true,
+        detail: `installed loader entry ${shortenPath(loaderEntryPath)} pins activation root ${shortenPath(path.resolve(activationRoot))}`
+    };
+}
+function describeAdditionalInstallDetail(additionalInstalls) {
+    if (additionalInstalls.length === 0) {
+        return "";
+    }
+    return `; additional OpenClawBrain installs also exist at ${additionalInstalls
+        .map((install) => `${shortenPath(install.extensionDir)} (${describeOpenClawBrainInstallLayout(install.installLayout)}, ${describeOpenClawBrainInstallIdentity(install)})`)
+        .join(", ")}`;
+}
 export function inspectOpenClawBrainPluginAllowlist(openclawHome) {
     const { path: openclawJsonPath, config } = readOpenClawJsonConfig(openclawHome);
+    const installedPlugin = findInstalledOpenClawBrainPlugin(openclawHome);
+    const knownPluginIds = getOpenClawBrainKnownPluginIds(installedPlugin.selectedInstall);
     const plugins = readJsonObjectRecord(config.plugins);
     if (plugins === null) {
         return {
@@ -55,14 +97,15 @@ export function inspectOpenClawBrainPluginAllowlist(openclawHome) {
             detail: `${shortenPath(openclawJsonPath)} has a non-array plugins.allow value, so OpenClawBrain load cannot be proven from config`
         };
     }
-    return plugins.allow.includes("openclawbrain")
+    const matchedPluginId = knownPluginIds.find((pluginId) => plugins.allow.includes(pluginId)) ?? null;
+    return matchedPluginId !== null
         ? {
             state: "allowed",
-            detail: `${shortenPath(openclawJsonPath)} plugins.allow explicitly includes openclawbrain`
+            detail: `${shortenPath(openclawJsonPath)} plugins.allow explicitly includes ${matchedPluginId}; recognized OpenClawBrain ids are ${knownPluginIds.join(", ")}`
         }
         : {
             state: "blocked",
-            detail: `${shortenPath(openclawJsonPath)} plugins.allow excludes openclawbrain`
+            detail: `${shortenPath(openclawJsonPath)} plugins.allow excludes recognized OpenClawBrain ids ${knownPluginIds.join(", ")}`
         };
 }
 export function inspectOpenClawBrainHookStatus(openclawHome) {
@@ -70,9 +113,16 @@ export function inspectOpenClawBrainHookStatus(openclawHome) {
         return {
             scope: "activation_root_only",
             openclawHome: null,
+            extensionDir: null,
             hookPath: null,
             runtimeGuardPath: null,
             manifestPath: null,
+            packageJsonPath: null,
+            manifestId: null,
+            installId: null,
+            packageName: null,
+            installLayout: null,
+            additionalInstallCount: 0,
             installState: "unverified",
             loadability: "unverified",
             pluginAllowlistState: "unverified",
@@ -81,66 +131,122 @@ export function inspectOpenClawBrainHookStatus(openclawHome) {
         };
     }
     const resolvedHome = path.resolve(openclawHome);
-    const extensionDir = path.join(resolvedHome, "extensions", "openclawbrain");
-    const hookPath = path.join(extensionDir, "index.ts");
-    const runtimeGuardPath = path.join(extensionDir, "runtime-guard.js");
-    const manifestPath = path.join(extensionDir, "openclaw.plugin.json");
-    if (!(existsSync(hookPath) && existsSync(runtimeGuardPath) && existsSync(manifestPath))) {
+    const installedPlugin = findInstalledOpenClawBrainPlugin(resolvedHome);
+    if (installedPlugin.selectedInstall === null ||
+        installedPlugin.selectedInstall.loaderEntryPath === null ||
+        installedPlugin.selectedInstall.runtimeGuardPath === null) {
+        const incompleteInstall = installedPlugin.selectedInstall;
         return {
             scope: "exact_openclaw_home",
             openclawHome: resolvedHome,
-            hookPath,
-            runtimeGuardPath,
-            manifestPath,
+            extensionDir: incompleteInstall?.extensionDir ?? null,
+            hookPath: incompleteInstall?.loaderEntryPath ?? null,
+            runtimeGuardPath: incompleteInstall?.runtimeGuardPath ?? null,
+            manifestPath: incompleteInstall?.manifestPath ?? null,
+            packageJsonPath: incompleteInstall?.packageJsonPath ?? null,
+            manifestId: incompleteInstall?.manifestId ?? null,
+            installId: incompleteInstall?.installId ?? null,
+            packageName: incompleteInstall?.packageName ?? null,
+            installLayout: incompleteInstall?.installLayout ?? null,
+            additionalInstallCount: installedPlugin.additionalInstalls.length,
             installState: "not_installed",
             loadability: "not_installed",
             pluginAllowlistState: "unverified",
             desynced: false,
-            detail: `profile hook is not present at ${shortenPath(extensionDir)}`
+            detail: incompleteInstall === null
+                ? `profile hook is not present under ${shortenPath(installedPlugin.extensionsDir)}`
+                : `profile hook is incomplete under ${shortenPath(incompleteInstall.extensionDir)} (${describeOpenClawBrainInstallIdentity(incompleteInstall)})`
         };
     }
+    const selectedInstall = installedPlugin.selectedInstall;
+    const additionalInstallDetail = describeAdditionalInstallDetail(installedPlugin.additionalInstalls);
     const allowlist = inspectOpenClawBrainPluginAllowlist(resolvedHome);
+    const layoutLabel = describeOpenClawBrainInstallLayout(selectedInstall.installLayout);
+    const identityDetail = describeOpenClawBrainInstallIdentity(selectedInstall);
+    const activationRootState = inspectInstalledHookActivationRoot(selectedInstall.loaderEntryPath);
     if (allowlist.state === "blocked") {
         return {
             scope: "exact_openclaw_home",
             openclawHome: resolvedHome,
-            hookPath,
-            runtimeGuardPath,
-            manifestPath,
+            extensionDir: selectedInstall.extensionDir,
+            hookPath: selectedInstall.loaderEntryPath,
+            runtimeGuardPath: selectedInstall.runtimeGuardPath,
+            manifestPath: selectedInstall.manifestPath,
+            packageJsonPath: selectedInstall.packageJsonPath,
+            manifestId: selectedInstall.manifestId,
+            installId: selectedInstall.installId,
+            packageName: selectedInstall.packageName,
+            installLayout: selectedInstall.installLayout,
+            additionalInstallCount: installedPlugin.additionalInstalls.length,
             installState: "blocked_by_allowlist",
             loadability: "blocked",
             pluginAllowlistState: allowlist.state,
             desynced: true,
-            detail: `profile hook files exist at ${shortenPath(extensionDir)}, but ${allowlist.detail}; ` +
-                "the on-disk hook is desynced and OpenClaw will not load it"
+            detail: `profile hook is installed via ${layoutLabel} at ${shortenPath(selectedInstall.extensionDir)} (${identityDetail}), but ${allowlist.detail}; ` +
+                `the on-disk hook is not loadable and OpenClaw will not load it${additionalInstallDetail}`
         };
     }
     if (allowlist.state === "invalid") {
         return {
             scope: "exact_openclaw_home",
             openclawHome: resolvedHome,
-            hookPath,
-            runtimeGuardPath,
-            manifestPath,
+            extensionDir: selectedInstall.extensionDir,
+            hookPath: selectedInstall.loaderEntryPath,
+            runtimeGuardPath: selectedInstall.runtimeGuardPath,
+            manifestPath: selectedInstall.manifestPath,
+            packageJsonPath: selectedInstall.packageJsonPath,
+            manifestId: selectedInstall.manifestId,
+            installId: selectedInstall.installId,
+            packageName: selectedInstall.packageName,
+            installLayout: selectedInstall.installLayout,
+            additionalInstallCount: installedPlugin.additionalInstalls.length,
             installState: "blocked_by_allowlist",
             loadability: "blocked",
             pluginAllowlistState: allowlist.state,
             desynced: true,
-            detail: `profile hook files exist at ${shortenPath(extensionDir)}, but ${allowlist.detail}; ` +
-                "treat hook-load state as broken until install/attach repairs the config"
+            detail: `profile hook is installed via ${layoutLabel} at ${shortenPath(selectedInstall.extensionDir)} (${identityDetail}), but ${allowlist.detail}; ` +
+                `treat hook-load state as broken until install/attach repairs the config${additionalInstallDetail}`
+        };
+    }
+    if (!activationRootState.ready) {
+        return {
+            scope: "exact_openclaw_home",
+            openclawHome: resolvedHome,
+            extensionDir: selectedInstall.extensionDir,
+            hookPath: selectedInstall.loaderEntryPath,
+            runtimeGuardPath: selectedInstall.runtimeGuardPath,
+            manifestPath: selectedInstall.manifestPath,
+            packageJsonPath: selectedInstall.packageJsonPath,
+            manifestId: selectedInstall.manifestId,
+            installId: selectedInstall.installId,
+            packageName: selectedInstall.packageName,
+            installLayout: selectedInstall.installLayout,
+            additionalInstallCount: installedPlugin.additionalInstalls.length,
+            installState: "installed",
+            loadability: "blocked",
+            pluginAllowlistState: allowlist.state,
+            desynced: true,
+            detail: `profile hook is installed via ${layoutLabel} at ${shortenPath(selectedInstall.extensionDir)} (${identityDetail}), but ${activationRootState.detail}${additionalInstallDetail}`
         };
     }
     return {
         scope: "exact_openclaw_home",
         openclawHome: resolvedHome,
-        hookPath,
-        runtimeGuardPath,
-        manifestPath,
+        extensionDir: selectedInstall.extensionDir,
+        hookPath: selectedInstall.loaderEntryPath,
+        runtimeGuardPath: selectedInstall.runtimeGuardPath,
+        manifestPath: selectedInstall.manifestPath,
+        packageJsonPath: selectedInstall.packageJsonPath,
+        manifestId: selectedInstall.manifestId,
+        installId: selectedInstall.installId,
+        packageName: selectedInstall.packageName,
+        installLayout: selectedInstall.installLayout,
+        additionalInstallCount: installedPlugin.additionalInstalls.length,
         installState: "installed",
         loadability: "loadable",
         pluginAllowlistState: allowlist.state,
         desynced: false,
-        detail: `profile hook is installed at ${shortenPath(extensionDir)}`
+        detail: `profile hook is installed via ${layoutLabel} at ${shortenPath(selectedInstall.extensionDir)} (${identityDetail})${additionalInstallDetail}`
     };
 }
 export function summarizeOpenClawBrainHookLoad(inspection, statusProbeReady) {
@@ -151,4 +257,4 @@ export function summarizeOpenClawBrainHookLoad(inspection, statusProbeReady) {
             : "not_ready"
     };
 }
-//# sourceMappingURL=openclaw-hook-truth.js.map
+//# sourceMappingURL=openclaw-hook-truth.js.map

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

@@ -0,0 +1,40 @@
+export type OpenClawBrainInstallLayout = "generated_shadow_extension" | "native_package_plugin";
+export interface OpenClawBrainInstalledPlugin {
+    openclawHome: string;
+    extensionsDir: string;
+    extensionDir: string;
+    manifestPath: string;
+    packageJsonPath: string;
+    loaderEntryPath: string | null;
+    runtimeGuardPath: string | null;
+    configuredEntries: string[];
+    manifestId: string | null;
+    installId: string | null;
+    packageName: string | null;
+    installLayout: OpenClawBrainInstallLayout;
+}
+export interface OpenClawBrainInstallTarget {
+    installLayout: OpenClawBrainInstallLayout;
+    extensionDir: string;
+    hookPath: string;
+    writeMode: "pin_native_package" | "write_shadow_extension";
+    selectedInstall: OpenClawBrainInstalledPlugin | null;
+    additionalInstalls: OpenClawBrainInstalledPlugin[];
+}
+export interface OpenClawBrainInstalledPluginLookup {
+    openclawHome: string;
+    extensionsDir: string;
+    selectedInstall: OpenClawBrainInstalledPlugin | null;
+    additionalInstalls: OpenClawBrainInstalledPlugin[];
+}
+export declare const OPENCLAWBRAIN_PLUGIN_ID = "openclawbrain";
+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 getOpenClawBrainKnownPluginIds(install: OpenClawBrainInstalledPlugin | null | undefined): string[];
+export declare function describeOpenClawBrainInstallIdentity(install: OpenClawBrainInstalledPlugin): string;
+export declare function findInstalledOpenClawBrainPlugin(openclawHome: string, pluginId?: string): OpenClawBrainInstalledPluginLookup;
+export declare function resolveOpenClawBrainInstallTarget(openclawHome: string): OpenClawBrainInstallTarget;
+export declare function pinInstalledOpenClawBrainPluginActivationRoot(loaderEntryPath: string, activationRoot: string): void;
+export declare function resolveOpenClawHomeFromExtensionEntryPath(extensionEntryPath: string): string | null;

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

@@ -0,0 +1,282 @@
+import { existsSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import path from "node:path";
+export const OPENCLAWBRAIN_PLUGIN_ID = "openclawbrain";
+export const OPENCLAWBRAIN_SHADOW_PACKAGE_NAME = "openclawbrain";
+export const OPENCLAWBRAIN_NATIVE_PACKAGE_NAME = "@openclawbrain/openclaw";
+export const OPENCLAWBRAIN_NATIVE_INSTALL_ID = "openclaw";
+function readJsonObject(filePath) {
+    try {
+        const parsed = JSON.parse(readFileSync(filePath, "utf8"));
+        if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function resolveConfiguredEntries(packageJson) {
+    const entries = packageJson?.openclaw?.extensions;
+    if (!Array.isArray(entries)) {
+        return [];
+    }
+    return entries
+        .filter((entry) => typeof entry === "string")
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0);
+}
+function resolveLoaderEntryPath(extensionDir, configuredEntries) {
+    for (const configuredEntry of configuredEntries) {
+        const candidate = path.join(extensionDir, configuredEntry);
+        if (existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function resolveRuntimeGuardPath(loaderEntryPath) {
+    const runtimeGuardPath = path.join(path.dirname(loaderEntryPath), "runtime-guard.js");
+    return existsSync(runtimeGuardPath) ? runtimeGuardPath : null;
+}
+function normalizeOptionalString(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function normalizeInstallId(value) {
+    const normalized = normalizeOptionalString(value);
+    if (normalized === null) {
+        return null;
+    }
+    if (!normalized.startsWith("@")) {
+        return normalized;
+    }
+    const parts = normalized.split("/");
+    return normalizeOptionalString(parts[1] ?? null);
+}
+function listCandidateExtensionDirs(extensionsDir) {
+    const candidates = [];
+    let entries;
+    try {
+        entries = readdirSync(extensionsDir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        const directPath = path.join(extensionsDir, entry.name);
+        candidates.push(directPath);
+        if (!entry.name.startsWith("@")) {
+            continue;
+        }
+        let scopedEntries;
+        try {
+            scopedEntries = readdirSync(directPath, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const scopedEntry of scopedEntries) {
+            if (!scopedEntry.isDirectory()) {
+                continue;
+            }
+            candidates.push(path.join(directPath, scopedEntry.name));
+        }
+    }
+    return candidates.sort((left, right) => left.localeCompare(right));
+}
+function inferInstallLayout(input) {
+    if (input.packageName === OPENCLAWBRAIN_NATIVE_PACKAGE_NAME) {
+        return "native_package_plugin";
+    }
+    if (input.packageName === OPENCLAWBRAIN_SHADOW_PACKAGE_NAME) {
+        return "generated_shadow_extension";
+    }
+    if (input.installId === OPENCLAWBRAIN_NATIVE_INSTALL_ID &&
+        input.loaderEntryPath !== null &&
+        input.loaderEntryPath.endsWith(path.join("dist", "extension", "index.js"))) {
+        return "native_package_plugin";
+    }
+    if (input.loaderEntryPath !== null &&
+        input.loaderEntryPath.endsWith(path.join("dist", "extension", "index.js"))) {
+        return "native_package_plugin";
+    }
+    if (input.loaderEntryPath !== null &&
+        path.basename(input.loaderEntryPath) === "index.ts" &&
+        (input.installId === OPENCLAWBRAIN_PLUGIN_ID ||
+            path.basename(input.extensionDir) === OPENCLAWBRAIN_PLUGIN_ID)) {
+        return "generated_shadow_extension";
+    }
+    return null;
+}
+function compareInstalledPluginPriority(left, right) {
+    const leftCompleteness = Number(left.loaderEntryPath !== null) + Number(left.runtimeGuardPath !== null);
+    const rightCompleteness = Number(right.loaderEntryPath !== null) + Number(right.runtimeGuardPath !== null);
+    if (leftCompleteness !== rightCompleteness) {
+        return rightCompleteness - leftCompleteness;
+    }
+    const leftLayoutRank = left.installLayout === "native_package_plugin" ? 0 : 1;
+    const rightLayoutRank = right.installLayout === "native_package_plugin" ? 0 : 1;
+    if (leftLayoutRank !== rightLayoutRank) {
+        return leftLayoutRank - rightLayoutRank;
+    }
+    return left.extensionDir.localeCompare(right.extensionDir);
+}
+function inspectOpenClawBrainPluginInstall(extensionDir, pluginId) {
+    const manifestPath = path.join(extensionDir, "openclaw.plugin.json");
+    if (!existsSync(manifestPath)) {
+        return null;
+    }
+    const manifest = readJsonObject(manifestPath);
+    const manifestId = normalizeOptionalString(manifest?.id);
+    if (manifestId !== pluginId) {
+        return null;
+    }
+    const packageJsonPath = path.join(extensionDir, "package.json");
+    if (!existsSync(packageJsonPath)) {
+        return null;
+    }
+    const packageJson = readJsonObject(packageJsonPath);
+    if (packageJson === null) {
+        return null;
+    }
+    const configuredEntries = resolveConfiguredEntries(packageJson);
+    const loaderEntryPath = resolveLoaderEntryPath(extensionDir, configuredEntries);
+    const packageName = typeof packageJson.name === "string" && packageJson.name.trim().length > 0
+        ? packageJson.name.trim()
+        : null;
+    const installId = normalizeInstallId(packageName) ?? normalizeInstallId(path.basename(extensionDir));
+    const installLayout = inferInstallLayout({
+        extensionDir,
+        packageName,
+        installId,
+        loaderEntryPath
+    });
+    if (installLayout === null) {
+        return null;
+    }
+    return {
+        extensionDir,
+        manifestPath,
+        packageJsonPath,
+        loaderEntryPath,
+        runtimeGuardPath: loaderEntryPath === null ? null : resolveRuntimeGuardPath(loaderEntryPath),
+        configuredEntries,
+        manifestId,
+        installId,
+        packageName,
+        installLayout
+    };
+}
+export function describeOpenClawBrainInstallLayout(installLayout) {
+    return installLayout === "native_package_plugin"
+        ? "native package plugin"
+        : "generated shadow extension";
+}
+export function getOpenClawBrainKnownPluginIds(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);
+    if (install?.packageName === OPENCLAWBRAIN_NATIVE_PACKAGE_NAME) {
+        push(OPENCLAWBRAIN_NATIVE_INSTALL_ID);
+    }
+    return ids;
+}
+export function describeOpenClawBrainInstallIdentity(install) {
+    return [
+        `manifest=${install.manifestId ?? OPENCLAWBRAIN_PLUGIN_ID}`,
+        `install=${install.installId ?? path.basename(install.extensionDir)}`,
+        `package=${install.packageName ?? "unknown"}`
+    ].join(" ");
+}
+export function findInstalledOpenClawBrainPlugin(openclawHome, pluginId = OPENCLAWBRAIN_PLUGIN_ID) {
+    const resolvedOpenclawHome = path.resolve(openclawHome);
+    const extensionsDir = path.join(resolvedOpenclawHome, "extensions");
+    if (!existsSync(extensionsDir)) {
+        return {
+            openclawHome: resolvedOpenclawHome,
+            extensionsDir,
+            selectedInstall: null,
+            additionalInstalls: []
+        };
+    }
+    const installs = listCandidateExtensionDirs(extensionsDir)
+        .map((extensionDir) => inspectOpenClawBrainPluginInstall(extensionDir, pluginId))
+        .filter((install) => install !== null)
+        .map((install) => ({
+        ...install,
+        openclawHome: resolvedOpenclawHome,
+        extensionsDir
+    }))
+        .sort(compareInstalledPluginPriority);
+    return {
+        openclawHome: resolvedOpenclawHome,
+        extensionsDir,
+        selectedInstall: installs[0] ?? null,
+        additionalInstalls: installs.slice(1)
+    };
+}
+export function resolveOpenClawBrainInstallTarget(openclawHome) {
+    const installedPlugin = findInstalledOpenClawBrainPlugin(openclawHome);
+    const selectedInstall = installedPlugin.selectedInstall;
+    if (selectedInstall !== null &&
+        selectedInstall.installLayout === "native_package_plugin" &&
+        selectedInstall.loaderEntryPath !== null &&
+        selectedInstall.runtimeGuardPath !== null) {
+        return {
+            installLayout: selectedInstall.installLayout,
+            extensionDir: selectedInstall.extensionDir,
+            hookPath: selectedInstall.loaderEntryPath,
+            writeMode: "pin_native_package",
+            selectedInstall,
+            additionalInstalls: installedPlugin.additionalInstalls
+        };
+    }
+    const extensionDir = path.join(openclawHome, "extensions", OPENCLAWBRAIN_PLUGIN_ID);
+    return {
+        installLayout: "generated_shadow_extension",
+        extensionDir,
+        hookPath: path.join(extensionDir, "index.ts"),
+        writeMode: "write_shadow_extension",
+        selectedInstall,
+        additionalInstalls: installedPlugin.additionalInstalls
+    };
+}
+export function pinInstalledOpenClawBrainPluginActivationRoot(loaderEntryPath, activationRoot) {
+    const loaderSource = readFileSync(loaderEntryPath, "utf8");
+    const pinnedActivationRoot = `const ACTIVATION_ROOT = ${JSON.stringify(activationRoot)};`;
+    const nextLoaderSource = loaderSource.replace(/const\s+ACTIVATION_ROOT\s*=\s*["'`][^"'`]*["'`];/, pinnedActivationRoot);
+    if (nextLoaderSource === loaderSource) {
+        throw new Error(`Installed loader entry ${loaderEntryPath} does not expose a patchable ACTIVATION_ROOT constant`);
+    }
+    writeFileSync(loaderEntryPath, nextLoaderSource, "utf8");
+}
+export function resolveOpenClawHomeFromExtensionEntryPath(extensionEntryPath) {
+    let currentPath = path.resolve(extensionEntryPath);
+    while (true) {
+        const parentPath = path.dirname(currentPath);
+        if (parentPath === currentPath) {
+            break;
+        }
+        if (path.basename(parentPath) === "extensions") {
+            return path.dirname(parentPath);
+        }
+        currentPath = parentPath;
+    }
+    return null;
+}
+//# sourceMappingURL=openclaw-plugin-install.js.map