@openclawbrain/openclaw 0.3.2 → 0.3.3

package/dist/src/cli.js

@@ -13,7 +13,8 @@ import { buildTeacherSupervisionArtifactsFromNormalizedEventExport, createAlways
 import { inspectActivationState, loadPackFromActivation, promoteCandidatePack, readLearningSpineLogEntries, stageCandidatePack } from "@openclawbrain/pack-format";
 import { resolveActivationRoot } from "./resolve-activation-root.js";
 import { describeOpenClawHomeInspection, discoverOpenClawHomes, formatOpenClawHomeLayout, formatOpenClawHomeProfileSource, inspectOpenClawHome } from "./openclaw-home-layout.js";
-import { DEFAULT_WATCH_POLL_INTERVAL_SECONDS, buildNormalizedEventExportFromScannedEvents, bootstrapRuntimeAttach, buildOperatorSurfaceReport, compileRuntimeContext, createAsyncTeacherLiveLoop, createOpenClawLocalSessionTail, createRuntimeEventExportScanner, describeCurrentProfileBrainStatus, formatOperatorRollbackReport, loadWatchTeacherSnapshotState, loadRuntimeEventExportBundle, persistWatchTeacherSnapshot, rollbackRuntimeAttach, resolveOperatorTeacherSnapshotPath, resolveAsyncTeacherLiveLoopSnapshotPath, resolveWatchSessionTailCursorPath, resolveWatchStateRoot, resolveWatchTeacherSnapshotPath, scanLiveEventExport, scanRecordedSession, summarizeLearningPathFromMaterialization, summarizeNormalizedEventExportLabelFlow, writeScannedEventExportBundle } from "./index.js";
+import { inspectOpenClawBrainHookStatus, inspectOpenClawBrainPluginAllowlist } from "./openclaw-hook-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 { discoverOpenClawSessionStores, loadOpenClawSessionIndex, readOpenClawSessionFile } from "./session-store.js";
@@ -38,6 +39,15 @@ function normalizeOptionalCliString(value) {
     const trimmed = value.trim();
     return trimmed.length > 0 ? trimmed : null;
 }
+function canonicalizeExistingCliPath(filePath) {
+    const resolvedPath = path.resolve(filePath);
+    try {
+        return realpathSync(resolvedPath);
+    }
+    catch {
+        return resolvedPath;
+    }
+}
 function readTruthyEnvFlag(name, env = process.env) {
     const value = normalizeOptionalCliString(env[name]);
     if (value === null) {
@@ -51,6 +61,45 @@ function getCliHomeDir() {
 function discoverInstallCandidateOpenClawHomes(homeDir = getCliHomeDir()) {
     return discoverOpenClawHomes(homeDir).map((inspection) => inspection.openclawHome);
 }
+function summarizeSharedActivationRootReferenceProof(reference) {
+    switch (reference.installState) {
+        case "installed":
+            return "hook installed and loadable";
+        case "blocked_by_allowlist":
+            return "hook files exist but OpenClaw will not load them because plugins.allow blocks openclawbrain";
+        case "not_installed":
+        default:
+            return "hook files are incomplete, so serve-path attachment is not proven";
+    }
+}
+function partitionSharedActivationRootHookReferences(references) {
+    return references.reduce((result, reference) => {
+        if (reference.serveAttachmentState === "attached") {
+            result.attached.push(reference);
+        }
+        else {
+            result.halfAttached.push(reference);
+        }
+        return result;
+    }, {
+        attached: [],
+        halfAttached: []
+    });
+}
+function formatSharedActivationRootReferenceList(references, options = {}) {
+    return references
+        .map((reference) => {
+        const parts = [path.resolve(reference.openclawHome)];
+        if (options.includeInspection) {
+            parts.push(describeOpenClawHomeInspection(reference.inspection));
+        }
+        if (options.includeProof) {
+            parts.push(summarizeSharedActivationRootReferenceProof(reference));
+        }
+        return `  - ${parts.join(" | ")}`;
+    })
+        .join("\n");
+}
 function findInstalledHookReferencesForActivationRoot(input) {
     const resolvedActivationRoot = path.resolve(input.activationRoot);
     const resolvedExcludedHome = input.excludingOpenClawHome === undefined || input.excludingOpenClawHome === null
@@ -66,8 +115,18 @@ function findInstalledHookReferencesForActivationRoot(input) {
         if (installedActivationRoot.trim().length === 0) {
             return [];
         }
+        const installHook = summarizeStatusInstallHook(inspection.openclawHome);
+        const reference = {
+            openclawHome: inspection.openclawHome,
+            inspection,
+            installState: installHook.state === "installed" || installHook.state === "blocked_by_allowlist"
+                ? installHook.state
+                : "not_installed",
+            serveAttachmentState: installHook.state === "installed" ? "attached" : "half_attached",
+            hookDetail: installHook.detail
+        };
         return path.resolve(installedActivationRoot) === resolvedActivationRoot
-            ? [{ openclawHome: inspection.openclawHome, inspection }]
+            ? [reference]
             : [];
     })
         .sort((left, right) => left.openclawHome.localeCompare(right.openclawHome));
@@ -76,11 +135,18 @@ function findOtherInstalledHookReferencesForActivationRoot(input) {
     return findInstalledHookReferencesForActivationRoot(input);
 }
 function resolveWatchProfileRootsForActivationRoot(activationRoot, homeDir = getCliHomeDir()) {
-    const attachedProfileRoots = findInstalledHookReferencesForActivationRoot({
+    const references = findInstalledHookReferencesForActivationRoot({
         activationRoot,
         homeDir
-    }).map((reference) => path.resolve(reference.openclawHome));
-    return attachedProfileRoots.length > 0 ? attachedProfileRoots : undefined;
+    });
+    const partitioned = partitionSharedActivationRootHookReferences(references);
+    const attachedProfileRoots = partitioned.attached.map((reference) => path.resolve(reference.openclawHome));
+    return {
+        attachedProfileRoots: attachedProfileRoots.length > 0 || references.length > 0
+            ? attachedProfileRoots
+            : undefined,
+        halfAttachedReferences: partitioned.halfAttached
+    };
 }
 function assertActivationRootPurgeIsNotShared(input) {
     const sharedReferences = findOtherInstalledHookReferencesForActivationRoot({
@@ -90,16 +156,36 @@ function assertActivationRootPurgeIsNotShared(input) {
     if (sharedReferences.length === 0) {
         return;
     }
-    const attachedProfiles = sharedReferences
-        .map(({ openclawHome, inspection }) => `  - ${path.resolve(openclawHome)} (${describeOpenClawHomeInspection(inspection)})`)
-        .join("\n");
-    throw new Error([
-        `Refusing to purge activation root ${path.resolve(input.activationRoot)} because another installed OpenClaw profile still points at it.`,
-        "Other attached profiles:",
-        attachedProfiles,
-        "Use uninstall --keep-data or detach on this profile first, then remove the remaining profile hooks before purging shared brain data.",
-        "For Eagle dogfood, prefer its own activation root so CormorantAI stays untouched."
-    ].join("\n"));
+    const partitioned = partitionSharedActivationRootHookReferences(sharedReferences);
+    const attachedProfiles = formatSharedActivationRootReferenceList(partitioned.attached, {
+        includeInspection: true,
+        includeProof: true
+    });
+    const halfAttachedProfiles = formatSharedActivationRootReferenceList(partitioned.halfAttached, {
+        includeInspection: true,
+        includeProof: true
+    });
+    throw new Error(partitioned.attached.length > 0
+        ? [
+            `Refusing to purge activation root ${path.resolve(input.activationRoot)} because another installed OpenClaw profile still points at it.`,
+            "Other attached profiles:",
+            attachedProfiles,
+            ...(partitioned.halfAttached.length === 0
+                ? []
+                : [
+                    "Other half-attached profiles:",
+                    halfAttachedProfiles
+                ]),
+            "Use uninstall --keep-data or detach on this profile first, then remove or repair the remaining profile hooks before purging shared brain data.",
+            "For Eagle dogfood, prefer its own activation root so CormorantAI stays untouched."
+        ].join("\n")
+        : [
+            `Refusing to purge activation root ${path.resolve(input.activationRoot)} because another OpenClaw profile still points at it, but its hook is not loadable yet.`,
+            "Other half-attached profiles:",
+            halfAttachedProfiles,
+            "Repair or remove those half-attached profile hooks before purging shared brain data so status stays explicit instead of drifting into a missing-root surprise.",
+            "For Eagle dogfood, prefer its own activation root so CormorantAI stays untouched."
+        ].join("\n"));
 }
 function formatInstallOpenClawHomeSource(source) {
     switch (source) {
@@ -541,6 +627,8 @@ function formatCompactList(values, maxItems = 2, maxLength = 64) {
     return values.length > maxItems ? `${visible.join("|")}+${values.length - maxItems}more` : visible.join("|");
 }
 const SERVICE_RISK_FINDING_CODES = new Set([
+    "hook_desynced",
+    "current_profile_not_attached",
     "activation_broken_install",
     "activation_stale_incomplete",
     "active_missing",
@@ -551,6 +639,7 @@ const SERVICE_RISK_FINDING_CODES = new Set([
     "serve_path_route_evidence_missing"
 ]);
 const DEGRADED_BRAIN_FINDING_CODES = new Set([
+    "attachment_scope_partial",
     "bootstrap_waiting_for_first_export",
     "serve_path_unprobed",
     "brain_context_kernel_only",
@@ -586,34 +675,180 @@ const TEACHER_NO_OP_MESSAGES = {
     unavailable: "the latest cycle is not visible from the current operator snapshot"
 };
 function summarizeStatusInstallHook(openclawHome) {
+    const hook = inspectOpenClawBrainHookStatus(openclawHome);
+    return {
+        state: hook.installState === "unverified" ? "unknown" : hook.installState,
+        detail: hook.detail
+    };
+}
+function summarizeStatusHookLoad(installHook, status) {
+    return {
+        installState: installHook.state === "unknown" ? "unverified" : installHook.state,
+        loadProof: status.hook.loadProof,
+        detail: status.hook.detail
+    };
+}
+function summarizeStatusConfigLoad(openclawHome) {
     if (openclawHome === null) {
         return {
-            state: "unknown",
-            detail: "profile hook state is unknown from activation-root-only status; pin --openclaw-home to prove install state"
+            state: "unverified",
+            detail: "plugin allowlist state is unknown from activation-root-only status; pin --openclaw-home to prove config load state"
         };
     }
-    const extensionDir = path.join(path.resolve(openclawHome), "extensions", "openclawbrain");
-    const indexPath = path.join(extensionDir, "index.ts");
-    const runtimeGuardPath = path.join(extensionDir, "runtime-guard.js");
-    const manifestPath = path.join(extensionDir, "openclaw.plugin.json");
-    if (existsSync(indexPath) && existsSync(runtimeGuardPath) && existsSync(manifestPath)) {
+    const allowlist = inspectOpenClawBrainPluginAllowlist(openclawHome);
+    if (allowlist.state === "blocked") {
         return {
-            state: "installed",
-            detail: `profile hook is installed at ${shortenPath(extensionDir)}`
+            state: "blocked",
+            detail: allowlist.detail
+        };
+    }
+    if (allowlist.state === "invalid") {
+        return {
+            state: "invalid",
+            detail: allowlist.detail
         };
     }
     return {
-        state: "not_installed",
-        detail: `profile hook is not present at ${shortenPath(extensionDir)}`
+        state: "allows_load",
+        detail: allowlist.detail
     };
 }
-function summarizeStatusHookLoad(installHook, status) {
+function summarizeStatusHookFilesState(installHook) {
+    if (installHook.state === "installed" || installHook.state === "blocked_by_allowlist") {
+        return "present";
+    }
+    if (installHook.state === "not_installed") {
+        return "missing";
+    }
+    return "unverified";
+}
+function summarizeStatusAttachmentWatcher(status) {
+    if (status.passiveLearning.watchState === "watching") {
+        return "alive";
+    }
+    if (status.passiveLearning.watchState === "stale_snapshot") {
+        return "stale";
+    }
+    return "not_visible";
+}
+function formatAttachedProfileIdentity(reference) {
+    const profileLabel = reference.inspection.profileId ?? "current_profile";
+    return `${profileLabel}@${shortenPath(path.resolve(reference.openclawHome))}`;
+}
+function buildStatusAttachedProfileTruth(input) {
+    const resolvedOpenClawHome = canonicalizeExistingCliPath(input.reference.openclawHome);
+    const installHook = summarizeStatusInstallHook(resolvedOpenClawHome);
+    const configLoad = summarizeStatusConfigLoad(resolvedOpenClawHome);
+    const runtimeProof = input.runtimeProofByHome.get(resolvedOpenClawHome);
+    const currentOpenClawHome = input.currentOpenClawHome === null ? null : canonicalizeExistingCliPath(input.currentOpenClawHome);
+    const hookFiles = summarizeStatusHookFilesState(installHook);
     return {
-        installState: installHook.state === "unknown" ? "unverified" : installHook.state,
-        loadProof: status.attachment.state === "attached" && status.brainStatus.serveState === "serving_active_pack"
-            ? "status_probe_ready"
-            : "not_ready",
-        detail: installHook.detail
+        label: formatAttachedProfileIdentity(input.reference),
+        openclawHome: resolvedOpenClawHome,
+        current: currentOpenClawHome !== null && currentOpenClawHome === resolvedOpenClawHome,
+        hookFiles,
+        configLoad: configLoad.state,
+        runtimeLoad: input.runtimeProofError !== null
+            ? "proof_error"
+            : hookFiles !== "present"
+                ? "not_proven"
+                : runtimeProof !== undefined
+                    ? "proven"
+                    : "not_proven",
+        runtimeLoadedAt: runtimeProof?.loadedAt ?? null
+    };
+}
+function buildCurrentStatusAttachmentTruthDetail(input) {
+    const attachedProfileCount = input.attachedProfiles.length;
+    const attachedProfilesDetail = attachedProfileCount === 0
+        ? "no attached profiles were discovered for this activation root"
+        : `attached profile set has ${attachedProfileCount} discoverable ${attachedProfileCount === 1 ? "profile" : "profiles"}`;
+    if (input.openclawHome === null) {
+        return ("current-profile hook/config/runtime load truth is unverified without --openclaw-home; " +
+            `${attachedProfilesDetail}`);
+    }
+    if (input.runtimeProofError !== null) {
+        return (`current profile ${input.currentProfileLabel} could not prove runtime load because ${shortenPath(input.runtimeProofPath)} is unreadable: ${input.runtimeProofError}; ` +
+            `${attachedProfilesDetail}`);
+    }
+    const hookDetail = input.hookFiles === "present"
+        ? "hook files are present"
+        : input.hookFiles === "missing"
+            ? "hook files are missing"
+            : "hook files are unverified";
+    const configDetail = input.configLoad === "allows_load"
+        ? "config allows load"
+        : input.configLoad === "blocked"
+            ? "config blocks load"
+            : input.configLoad === "invalid"
+                ? "config is invalid for load proof"
+                : "config load is unverified";
+    const runtimeDetail = input.runtimeLoad === "proven"
+        ? "runtime load is proven"
+        : input.runtimeLoad === "not_proven"
+            ? "runtime load is not yet proven"
+            : input.runtimeLoad === "proof_error"
+                ? "runtime load proof is broken"
+                : "runtime load is unverified";
+    const watcherDetail = input.watcher === "alive"
+        ? "watcher is alive"
+        : input.watcher === "stale"
+            ? "watcher visibility is stale"
+            : "watcher is not visible";
+    return `current profile ${input.currentProfileLabel}: ${hookDetail}, ${configDetail}, ${runtimeDetail}, ${watcherDetail}; ${attachedProfilesDetail}`;
+}
+function summarizeStatusAttachmentTruth(input) {
+    const runtimeProofs = listOpenClawProfileRuntimeLoadProofs(input.activationRoot);
+    const runtimeProofByHome = new Map();
+    for (const proof of runtimeProofs.proofs?.profiles ?? []) {
+        runtimeProofByHome.set(canonicalizeExistingCliPath(proof.openclawHome), {
+            loadedAt: proof.loadedAt
+        });
+    }
+    const attachedProfiles = findInstalledHookReferencesForActivationRoot({
+        activationRoot: input.activationRoot
+    }).map((reference) => buildStatusAttachedProfileTruth({
+        reference,
+        currentOpenClawHome: input.openclawHome,
+        runtimeProofByHome,
+        runtimeProofError: runtimeProofs.error
+    }));
+    const currentInspection = input.openclawHome === null ? null : inspectOpenClawHome(input.openclawHome);
+    const currentProfileLabel = currentInspection?.profileId ?? "current_profile";
+    const installHook = summarizeStatusInstallHook(input.openclawHome);
+    const configLoad = summarizeStatusConfigLoad(input.openclawHome);
+    const currentRuntimeProof = input.openclawHome === null ? undefined : runtimeProofByHome.get(canonicalizeExistingCliPath(input.openclawHome));
+    const hookFiles = summarizeStatusHookFilesState(installHook);
+    const watcher = summarizeStatusAttachmentWatcher(input.status);
+    const runtimeLoad = input.openclawHome === null
+        ? "unverified"
+        : runtimeProofs.error !== null
+            ? "proof_error"
+            : hookFiles !== "present"
+                ? "not_proven"
+                : currentRuntimeProof !== undefined
+                    ? "proven"
+                    : "not_proven";
+    return {
+        currentProfileLabel,
+        hookFiles,
+        configLoad: configLoad.state,
+        runtimeLoad,
+        watcher,
+        attachedProfiles,
+        runtimeProofPath: runtimeProofs.path,
+        runtimeProofError: runtimeProofs.error,
+        detail: buildCurrentStatusAttachmentTruthDetail({
+            openclawHome: input.openclawHome,
+            currentProfileLabel,
+            hookFiles,
+            configLoad: configLoad.state,
+            runtimeLoad,
+            watcher,
+            attachedProfiles,
+            runtimeProofPath: runtimeProofs.path,
+            runtimeProofError: runtimeProofs.error
+        })
     };
 }
 function runOllamaProbe(args, baseUrl) {
@@ -988,6 +1223,28 @@ function formatStatusObservedDeltaTransition(delta) {
     }
     return `${delta.latestPackTransition.kind}:${delta.latestPackTransition.fromPackId ?? "none"}->${delta.latestPackTransition.toPackId}`;
 }
+function formatAttachedProfileTruthCompact(entry) {
+    const currentPrefix = entry.current ? "*" : "";
+    return (`${currentPrefix}${entry.label}` +
+        `[hook=${entry.hookFiles} config=${entry.configLoad} runtime=${entry.runtimeLoad}` +
+        `${entry.runtimeLoadedAt === null ? "" : `@${entry.runtimeLoadedAt}`}]`);
+}
+function formatAttachedProfileTruthCompactList(entries) {
+    return entries.length === 0
+        ? "none"
+        : formatCompactList(entries.map((entry) => formatAttachedProfileTruthCompact(entry)), 2, 80);
+}
+function formatAttachedProfileTruthDetailedList(entries) {
+    return entries.length === 0
+        ? "none"
+        : entries
+            .map((entry) => `${entry.current ? "*" : ""}${entry.label}` +
+            `[hook=${entry.hookFiles} config=${entry.configLoad} runtime=${entry.runtimeLoad} loadedAt=${entry.runtimeLoadedAt ?? "none"}]`)
+            .join(" ");
+}
+function summarizeDisplayedStatus(status, installHook) {
+    return installHook.state === "blocked_by_allowlist" ? "fail" : status.brainStatus.status;
+}
 function buildCompactStatusHeader(status, report, options) {
     const installHook = summarizeStatusInstallHook(options.openclawHome);
     const hookLoad = summarizeStatusHookLoad(installHook, status);
@@ -998,9 +1255,15 @@ function buildCompactStatusHeader(status, report, options) {
     const routeFn = summarizeStatusRouteFn(status, report);
     const alerts = summarizeStatusAlerts(report, options.providerConfig, embeddings, localLlm);
     const liveModels = embeddings.models.length === 0 ? "none" : embeddings.models.join("|");
+    const attachmentTruth = summarizeStatusAttachmentTruth({
+        activationRoot: status.host.activationRoot,
+        openclawHome: options.openclawHome,
+        status
+    });
     return [
         `lifecycle   attach=${status.attachment.state} learner=${yesNo(status.passiveLearning.learnerRunning)} watch=${summarizeStatusWatchState(status)} export=${status.passiveLearning.exportState} promote=${summarizeStatusPromotionState(status)} serve=${summarizeStatusServeReality(status)}`,
         `hook        install=${hookLoad.installState} loadProof=${hookLoad.loadProof} detail=${hookLoad.detail}`,
+        `attachTruth current=${attachmentTruth.currentProfileLabel} hook=${attachmentTruth.hookFiles} config=${attachmentTruth.configLoad} runtime=${attachmentTruth.runtimeLoad} watcher=${attachmentTruth.watcher} attachedSet=${formatAttachedProfileTruthCompactList(attachmentTruth.attachedProfiles)} why=${attachmentTruth.detail}`,
         `passive     firstExport=${yesNo(status.passiveLearning.firstExportOccurred)} backlog=${status.passiveLearning.backlogState} pending=${formatStatusNullableNumber(status.passiveLearning.pendingLive)}/${formatStatusNullableNumber(status.passiveLearning.pendingBackfill)}`,
         `serving     pack=${status.passiveLearning.currentServingPackId ?? "none"} lastExport=${status.passiveLearning.lastExportAt ?? "none"} lastPromotion=${status.passiveLearning.lastPromotionAt ?? "none"}`,
         `timing      ${formatStatusHotPathTiming(status.brainStatus.timing)}`,
@@ -1017,21 +1280,34 @@ function buildCompactStatusHeader(status, report, options) {
     ];
 }
 function formatCurrentProfileStatusSummary(status, report, targetInspection, options) {
+    const installHook = summarizeStatusInstallHook(options.openclawHome);
+    const displayedStatus = summarizeDisplayedStatus(status, installHook);
     const embeddings = summarizeStatusEmbeddings(report, options.providerConfig);
     const localLlm = summarizeStatusLocalLlm(options.providerConfig);
     const liveModels = embeddings.models.length === 0 ? "none" : embeddings.models.join("|");
+    const attachmentTruth = summarizeStatusAttachmentTruth({
+        activationRoot: status.host.activationRoot,
+        openclawHome: options.openclawHome,
+        status
+    });
     const profileIdSuffix = status.profile.profileId === null ? "" : ` id=${status.profile.profileId}`;
     const targetLine = targetInspection === null
         ? `target      activation=${status.host.activationRoot} source=activation_root_only`
         : `target      activation=${status.host.activationRoot} ${formatOpenClawTargetLine(targetInspection)} hook=${shortenPath(path.join(targetInspection.openclawHome, "extensions", "openclawbrain", "index.ts"))}`;
     return [
-        `STATUS ${status.brainStatus.status}`,
+        `STATUS ${displayedStatus}`,
         ...buildCompactStatusHeader(status, report, options),
         `answer      ${status.brain.summary}`,
         targetLine,
         ...(targetInspection === null ? [] : [`preflight   ${formatOpenClawTargetExplanation(targetInspection)}`]),
+        `next        ${buildStatusNextStep(status, report, {
+            openclawHome: options.openclawHome,
+            installHook
+        })}`,
         `host        runtime=${status.host.runtimeOwner} activation=${status.host.activationRoot}`,
         `profile     selector=${status.profile.selector}${profileIdSuffix} attachment=${status.attachment.state} policy=${status.attachment.policyMode}`,
+        `attachTruth current=${attachmentTruth.currentProfileLabel} hook=${attachmentTruth.hookFiles} config=${attachmentTruth.configLoad} runtime=${attachmentTruth.runtimeLoad} watcher=${attachmentTruth.watcher} detail=${attachmentTruth.detail}`,
+        `attachedSet ${formatAttachedProfileTruthDetailedList(attachmentTruth.attachedProfiles)} proofPath=${shortenPath(attachmentTruth.runtimeProofPath)} proofError=${attachmentTruth.runtimeProofError ?? "none"}`,
         `manyProfile surface=${report.manyProfile.operatorSurface} policy=${report.manyProfile.declaredAttachmentPolicy} intent=${report.manyProfile.sameGatewayIntent} checkedProof=${report.manyProfile.checkedInProofTopology} sameGatewayProof=${yesNo(report.manyProfile.sameGatewayProof)} sharedWriteProof=${yesNo(report.manyProfile.sharedWriteSafetyProof)}`,
         `activation  state=${status.brainStatus.activationState} detail=${status.brain.detail}`,
         `brain       pack=${status.brain.activePackId ?? "none"} state=${status.brain.state} init=${status.brain.initMode ?? "unknown"} routeFreshness=${status.brain.routeFreshness} lastPromotion=${status.brain.lastPromotionAt ?? "none"} router=${status.brain.routerIdentity ?? "none"}`,
@@ -1472,6 +1748,19 @@ function buildCleanupRestartGuidance(restart) {
 }
 function buildStatusNextStep(status, report, options) {
     const activationRootArg = quoteShellArg(status.host.activationRoot);
+    const attachmentTruth = summarizeStatusAttachmentTruth({
+        activationRoot: status.host.activationRoot,
+        openclawHome: options.openclawHome,
+        status
+    });
+    if (options.installHook.state === "blocked_by_allowlist") {
+        if (options.openclawHome === null) {
+            return "Repair the OpenClaw plugin allowlist mismatch before trusting serve-path status again.";
+        }
+        return ("Repair the OpenClaw plugin allowlist mismatch " +
+            `(rerun ${buildInstallCommand(options.openclawHome)} or ${buildAttachCommand(options.openclawHome, status.host.activationRoot)}) ` +
+            "before trusting serve-path status again.");
+    }
     if (status.brainStatus.activationState === "broken_install") {
         return "Repair or replace the activation root before trusting serve-path status again.";
     }
@@ -1484,12 +1773,21 @@ function buildStatusNextStep(status, report, options) {
     if (options.openclawHome !== null && options.installHook.state === "not_installed") {
         return `Run \`${buildInstallCommand(options.openclawHome)}\` before expecting this OpenClaw home to load the brain hook.`;
     }
+    if (options.openclawHome !== null &&
+        attachmentTruth.hookFiles === "present" &&
+        attachmentTruth.configLoad === "allows_load" &&
+        attachmentTruth.runtimeLoad === "not_proven") {
+        return "Restart the exact OpenClaw profile or wait for its next launch, then rerun status until runtime load becomes proven instead of assumed from on-disk state.";
+    }
     if (status.brainStatus.awaitingFirstExport) {
         return `Let the attached OpenClaw profile emit a real export, then rerun \`openclawbrain status --activation-root ${activationRootArg}\`.`;
     }
     if (options.openclawHome === null) {
         return `Pin \`--openclaw-home <path>\` when you need exact hook-install truth; activation-root-only status only proves this root's serve-path state.`;
     }
+    if (attachmentTruth.runtimeLoad === "proof_error") {
+        return "Repair the runtime-load proof file before trusting attach truth again; status now knows the exact file that broke.";
+    }
     if (options.installHook.state === "installed" && status.brainStatus.serveState === "serving_active_pack") {
         return "Check the OpenClaw startup log for the `[openclawbrain] BRAIN LOADED` breadcrumb when you need live hook-load proof.";
     }
@@ -1503,8 +1801,10 @@ function buildStatusNextStep(status, report, options) {
     return `Use \`openclawbrain status --activation-root ${activationRootArg} --detailed\` when you need the full lifecycle, serve-path, and backlog proof.`;
 }
 function formatHumanFriendlyStatus(status, report, targetInspection, options) {
+    const installHook = summarizeStatusInstallHook(options.openclawHome);
+    const displayedStatus = summarizeDisplayedStatus(status, installHook);
     const lines = [
-        `STATUS ${status.brainStatus.status}`,
+        `STATUS ${displayedStatus}`,
         ...buildCompactStatusHeader(status, report, options),
         ...(targetInspection === null ? [] : [
             `target      ${formatOpenClawTargetLine(targetInspection)}`,
@@ -1512,7 +1812,7 @@ function formatHumanFriendlyStatus(status, report, targetInspection, options) {
         ]),
         `next        ${buildStatusNextStep(status, report, {
             openclawHome: options.openclawHome,
-            installHook: summarizeStatusInstallHook(options.openclawHome)
+            installHook
         })}`
     ];
     return lines.join("\n");
@@ -2642,14 +2942,20 @@ function resolveCleanupLearnerServiceOutcome(activationRoot, openclawHome) {
         activationRoot,
         excludingOpenClawHome: openclawHome
     });
-    if (remainingProfiles.length > 0) {
+    const partitioned = partitionSharedActivationRootHookReferences(remainingProfiles);
+    if (partitioned.attached.length > 0) {
         const inspection = inspectManagedLearnerService(activationRoot);
-        const attachedProfiles = remainingProfiles
+        const attachedProfiles = partitioned.attached
             .map(({ openclawHome: profileHome }) => shortenPath(path.resolve(profileHome)))
             .join(", ");
+        const halfAttachedNote = partitioned.halfAttached.length === 0
+            ? ""
+            : ` Half-attached hooks still point at this root but were not counted as attached: ${partitioned.halfAttached
+                .map((reference) => `${shortenPath(path.resolve(reference.openclawHome))} (${summarizeSharedActivationRootReferenceProof(reference)})`)
+                .join(", ")}.`;
         return {
             state: "preserved",
-            detail: `Preserved the background learner service for ${path.resolve(activationRoot)} because other attached OpenClaw profiles still share this activation root: ${attachedProfiles}.`,
+            detail: `Preserved the background learner service for ${path.resolve(activationRoot)} because other attached OpenClaw profiles still share this activation root: ${attachedProfiles}.${halfAttachedNote}`,
             plistPath: inspection.plistPath,
             logPath: inspection.logPath,
             configuredActivationRoot: inspection.configuredActivationRoot,
@@ -2657,9 +2963,14 @@ function resolveCleanupLearnerServiceOutcome(activationRoot, openclawHome) {
         };
     }
     const outcome = removeManagedLearnerServiceForActivationRoot(activationRoot);
+    const halfAttachedNote = partitioned.halfAttached.length === 0
+        ? ""
+        : ` Ignored half-attached OpenClaw profile hooks that still point at this activation root because they do not prove serve-path attachment: ${partitioned.halfAttached
+            .map((reference) => `${shortenPath(path.resolve(reference.openclawHome))} (${summarizeSharedActivationRootReferenceProof(reference)})`)
+            .join(", ")}.`;
     return {
         state: outcome.state,
-        detail: outcome.detail,
+        detail: `${outcome.detail}${halfAttachedNote}`,
         plistPath: outcome.inspection.plistPath,
         logPath: outcome.inspection.logPath,
         configuredActivationRoot: outcome.inspection.configuredActivationRoot,
@@ -2952,6 +3263,8 @@ function runProfileHookAttachCommand(parsed) {
     const manifestPath = path.join(extensionDir, "openclaw.plugin.json");
     writeFileSync(manifestPath, buildExtensionPluginManifest(), "utf8");
     steps.push(`Wrote manifest: ${manifestPath}`);
+    const pluginConfigRepair = ensureOpenClawBrainPluginConfig(parsed.openclawHome);
+    steps.push(pluginConfigRepair.detail);
     const learnerService = ensureLifecycleLearnerService(parsed.activationRoot);
     steps.push(learnerService.detail);
     const brainFeedback = buildInstallBrainFeedbackSummary({
@@ -3084,6 +3397,7 @@ function runProfileHookAttachCommand(parsed) {
                     teacherBaseUrl: providerDefaults.defaults.teacherBaseUrl ?? null,
                     embedderBaseUrl: providerDefaults.defaults.embedderBaseUrl ?? null
                 },
+            pluginConfigRepair,
             learnerService,
             brainFeedback: {
                 hookPath: brainFeedback.hookPath,
@@ -3164,6 +3478,46 @@ function readOpenClawJsonConfig(openclawHome) {
         config
     };
 }
+function ensureOpenClawBrainPluginConfig(openclawHome) {
+    const { path: openclawJsonPath, config } = readOpenClawJsonConfig(openclawHome);
+    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`
+        };
+    }
+    if (plugins.allow.includes("openclawbrain")) {
+        return {
+            path: openclawJsonPath,
+            changed: false,
+            detail: `Verified ${shortenPath(openclawJsonPath)} plugins.allow already includes openclawbrain`
+        };
+    }
+    plugins.allow = [...plugins.allow, "openclawbrain"];
+    config.plugins = plugins;
+    writeFileSync(openclawJsonPath, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+    return {
+        path: openclawJsonPath,
+        changed: true,
+        detail: `Repaired ${shortenPath(openclawJsonPath)} plugins.allow by adding openclawbrain`
+    };
+}
 function scrubOpenClawBrainPluginConfig(openclawHome) {
     const { path: openclawJsonPath, config } = readOpenClawJsonConfig(openclawHome);
     const plugins = readJsonObjectRecord(config.plugins);
@@ -3256,12 +3610,30 @@ function summarizeKeptActivationData(activationRoot) {
 function buildRestartGuidance(restart) {
     return buildCleanupRestartGuidance(restart);
 }
+function clearCleanupRuntimeLoadProof(activationRoot, openclawHome, steps) {
+    if (activationRoot === null) {
+        return;
+    }
+    try {
+        const cleared = clearOpenClawProfileRuntimeLoadProof({
+            activationRoot,
+            openclawHome
+        });
+        if (cleared) {
+            steps.push(`Cleared runtime-load proof for ${shortenPath(openclawHome)} from ${shortenPath(resolveAttachmentRuntimeLoadProofsPath(activationRoot))}`);
+        }
+    }
+    catch (error) {
+        steps.push(`Runtime-load proof cleanup failed open at ${shortenPath(resolveAttachmentRuntimeLoadProofsPath(activationRoot))}: ${toErrorMessage(error)}`);
+    }
+}
 function runDetachCommand(parsed) {
     const steps = [];
     validateOpenClawHome(parsed.openclawHome);
     const targetInspection = inspectOpenClawHome(parsed.openclawHome);
     steps.push(`Detected layout: ${formatOpenClawTargetExplanation(targetInspection)}`);
     const activationRoot = resolveCleanupActivationRoot(parsed.openclawHome, parsed.activationRoot);
+    clearCleanupRuntimeLoadProof(activationRoot, parsed.openclawHome, steps);
     const learnerService = resolveCleanupLearnerServiceOutcome(activationRoot, parsed.openclawHome);
     const pluginConfigCleanup = scrubOpenClawBrainPluginConfig(parsed.openclawHome);
     const extensionDir = removeProfileHookup(parsed.openclawHome, steps);
@@ -3340,6 +3712,7 @@ function runUninstallCommand(parsed) {
     const targetInspection = inspectOpenClawHome(parsed.openclawHome);
     steps.push(`Detected layout: ${formatOpenClawTargetExplanation(targetInspection)}`);
     const activationRoot = resolveCleanupActivationRoot(parsed.openclawHome, parsed.activationRoot);
+    clearCleanupRuntimeLoadProof(activationRoot, parsed.openclawHome, steps);
     if (parsed.dataMode === "purge" && activationRoot !== null) {
         assertActivationRootPurgeIsNotShared({
             activationRoot,
@@ -4565,14 +4938,23 @@ export async function createWatchCommandRuntime(input) {
         const restoredSeenExportCount = restoredTeacherState.snapshot.state?.seenExportDigests.length ?? 0;
         log(`Restored teacher snapshot: seen=${restoredSeenExportCount} artifacts=${restoredTeacherState.snapshot.teacher.artifactCount}`);
     }
-    const resolvedProfileRoots = input.profileRoots === undefined
+    const resolvedWatchProfileScope = input.profileRoots === undefined
         ? resolveWatchProfileRootsForActivationRoot(activationRoot)
-        : [...new Set(input.profileRoots.map((root) => path.resolve(root)))];
-    if (input.profileRoots === undefined && resolvedProfileRoots !== undefined) {
+        : {
+            attachedProfileRoots: [...new Set(input.profileRoots.map((root) => path.resolve(root)))],
+            halfAttachedReferences: []
+        };
+    const resolvedProfileRoots = resolvedWatchProfileScope.attachedProfileRoots;
+    if (input.profileRoots === undefined && resolvedProfileRoots !== undefined && resolvedProfileRoots.length > 0) {
         log(`Session tail scope: attached OpenClaw home${resolvedProfileRoots.length === 1 ? "" : "s"} ${resolvedProfileRoots
             .map((root) => shortenPath(root))
             .join(", ")}`);
     }
+    if (input.profileRoots === undefined && resolvedWatchProfileScope.halfAttachedReferences.length > 0) {
+        log(`Session tail scope skipped half-attached OpenClaw home${resolvedWatchProfileScope.halfAttachedReferences.length === 1 ? "" : "s"} ${resolvedWatchProfileScope.halfAttachedReferences
+            .map((reference) => `${shortenPath(path.resolve(reference.openclawHome))} (${summarizeSharedActivationRootReferenceProof(reference)})`)
+            .join(", ")}`);
+    }
     let restoredCursor = loadWatchSessionTailCursor(sessionTailCursorPath);
     let localSessionTail;
     try {
@@ -5097,6 +5479,10 @@ export function runOperatorCli(argv = process.argv.slice(2)) {
     const operatorInput = {
         ...statusOrRollback.input,
         activationRoot,
+        openclawHome: statusOrRollback.openclawHome,
+        ...(targetInspection?.profileId === null || targetInspection?.profileId === undefined
+            ? {}
+            : { profileId: targetInspection.profileId }),
         teacherSnapshotPath: resolveOperatorTeacherSnapshotPath(activationRoot, statusOrRollback.input.teacherSnapshotPath)
     };
     const status = describeCurrentProfileBrainStatus(operatorInput);