@openclawbrain/openclaw 0.3.1 → 0.3.3

package/dist/src/cli.js

@@ -5,19 +5,23 @@ import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-import { DEFAULT_OLLAMA_EMBEDDING_MODEL } from "@openclawbrain/compiler";
-import { parseDaemonArgs, runDaemonCommand } from "./daemon.js";
+import { DEFAULT_OLLAMA_EMBEDDING_MODEL, createOllamaEmbedder } from "@openclawbrain/compiler";
+import { ensureManagedLearnerServiceForActivationRoot, inspectManagedLearnerService, removeManagedLearnerServiceForActivationRoot, parseDaemonArgs, runDaemonCommand } from "./daemon.js";
 import { exportBrain, importBrain } from "./import-export.js";
 import { buildNormalizedEventExport } from "@openclawbrain/contracts";
-import { buildTeacherSupervisionArtifactsFromNormalizedEventExport, createAlwaysOnLearningRuntimeState, describeAlwaysOnLearningRuntimeState, drainAlwaysOnLearningRuntime, loadOrInitBaseline, materializeAlwaysOnLearningCandidatePack, persistBaseline } from "@openclawbrain/learner";
+import { buildTeacherSupervisionArtifactsFromNormalizedEventExport, createAlwaysOnLearningRuntimeState, describeAlwaysOnLearningRuntimeState, drainAlwaysOnLearningRuntime, loadOrInitBaseline, reindexCandidatePackBuildResultWithEmbedder, materializeAlwaysOnLearningCandidatePack, persistBaseline } from "@openclawbrain/learner";
 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 { 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";
-import { readOpenClawBrainProviderConfig, readOpenClawBrainProviderConfigFromSources, resolveOpenClawBrainProviderDefaultsPath } from "./provider-config.js";
+import { readOpenClawBrainProviderDefaults, readOpenClawBrainProviderConfig, readOpenClawBrainProviderConfigFromSources, resolveOpenClawBrainProviderDefaultsPath } from "./provider-config.js";
+const OPENCLAWBRAIN_EMBEDDER_BASE_URL_ENV = "OPENCLAWBRAIN_EMBEDDER_BASE_URL";
+const OPENCLAWBRAIN_EMBEDDER_PROVIDER_ENV = "OPENCLAWBRAIN_EMBEDDER_PROVIDER";
+const OPENCLAWBRAIN_EMBEDDER_MODEL_ENV = "OPENCLAWBRAIN_EMBEDDER_MODEL";
 const OPENCLAWBRAIN_INSTALL_SKIP_EMBEDDER_PROVISION_ENV = "OPENCLAWBRAIN_INSTALL_SKIP_EMBEDDER_PROVISION";
 const INSTALL_COMPATIBLE_LOCAL_TEACHER_MODEL_PREFIXES = [
     "qwen3.5:9b",
@@ -35,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) {
@@ -48,6 +61,132 @@ 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
+        ? null
+        : path.resolve(input.excludingOpenClawHome);
+    return discoverOpenClawHomes(input.homeDir ?? getCliHomeDir())
+        .filter((inspection) => resolvedExcludedHome === null || path.resolve(inspection.openclawHome) !== resolvedExcludedHome)
+        .flatMap((inspection) => {
+        const installedActivationRoot = resolveActivationRoot({
+            openclawHome: inspection.openclawHome,
+            quiet: true
+        });
+        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
+            ? [reference]
+            : [];
+    })
+        .sort((left, right) => left.openclawHome.localeCompare(right.openclawHome));
+}
+function findOtherInstalledHookReferencesForActivationRoot(input) {
+    return findInstalledHookReferencesForActivationRoot(input);
+}
+function resolveWatchProfileRootsForActivationRoot(activationRoot, homeDir = getCliHomeDir()) {
+    const references = findInstalledHookReferencesForActivationRoot({
+        activationRoot,
+        homeDir
+    });
+    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({
+        activationRoot: input.activationRoot,
+        excludingOpenClawHome: input.openclawHome
+    });
+    if (sharedReferences.length === 0) {
+        return;
+    }
+    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) {
         case "explicit":
@@ -418,6 +557,24 @@ function formatStructuralOps(report) {
         ? "none"
         : `split:${structuralOps.split},merge:${structuralOps.merge},prune:${structuralOps.prune},connect:${structuralOps.connect}`;
 }
+function formatGraphConnectDiagnostics(diagnostics) {
+    if (diagnostics === null) {
+        return "none";
+    }
+    return `budget:${diagnostics.requestedBudget},threshold:${diagnostics.scoreThreshold},pairs:${diagnostics.appliedPairCount}/${diagnostics.candidatePairCount},edges:${diagnostics.createdEdgeCount}`;
+}
+function formatCompactGraphConnectDiagnostics(diagnostics) {
+    if (diagnostics === null) {
+        return "none";
+    }
+    return `pairs:${diagnostics.appliedPairCount},edges:${diagnostics.createdEdgeCount}`;
+}
+function formatGraphSummary(report) {
+    return (report.graph.latestMaterialization.operatorSummary ??
+        report.graph.operatorSummary ??
+        report.graph.latestMaterialization.detail ??
+        report.graph.detail);
+}
 function formatScannerSurfaces(report) {
     return report.supervision.scanSurfaces.length === 0 ? "none" : report.supervision.scanSurfaces.join("|");
 }
@@ -470,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",
@@ -480,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",
@@ -506,26 +666,189 @@ const LEARNING_WARNING_MESSAGES = {
     teacher_no_artifacts: "teacher produced no artifacts",
     teacher_snapshot_unavailable: "teacher snapshot is unavailable"
 };
+const TEACHER_NO_OP_MESSAGES = {
+    none: "the latest processed export produced teacher artifacts",
+    duplicate_export: "the latest cycle was a no-op because the export was already seen",
+    queue_full: "the latest cycle was a no-op because the teacher queue was full",
+    no_teacher_artifacts: "the latest cycle was a no-op because no teacher artifacts were produced",
+    empty_scan: "the latest cycle was a no-op because the scanner did not produce any events",
+    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: "blocked",
+            detail: allowlist.detail
+        };
+    }
+    if (allowlist.state === "invalid") {
         return {
-            state: "installed",
-            detail: `profile hook is installed at ${shortenPath(extensionDir)}`
+            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 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 {
+        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) {
@@ -639,6 +962,162 @@ function summarizeStatusLocalLlm(providerConfig) {
             : `teacher labeling is ${providerConfig.teacher.provider}; no local Ollama CLI was detected`
     };
 }
+function summarizeStatusTeacher(report, providerConfig, localLlm) {
+    const enabled = providerConfig.teacher.provider === "ollama";
+    const latestCycle = report.teacherLoop.lastNoOpReason === "unavailable"
+        ? "unknown"
+        : report.teacherLoop.lastNoOpReason === "none"
+            ? "teacher_artifact"
+            : "no_op";
+    if (!enabled) {
+        return {
+            model: providerConfig.teacher.model,
+            enabled,
+            healthy: false,
+            stale: false,
+            idle: false,
+            latestCycle,
+            detail: `${providerConfig.teacher.model} is not enabled because teacher labeling is ${providerConfig.teacher.provider}`
+        };
+    }
+    if (!localLlm.detected) {
+        return {
+            model: providerConfig.teacher.model,
+            enabled,
+            healthy: false,
+            stale: null,
+            idle: false,
+            latestCycle,
+            detail: `${providerConfig.teacher.model} is configured on Ollama, but the local LLM surface is not answering at ${providerConfig.teacherBaseUrl}`
+        };
+    }
+    if (!report.teacherLoop.available) {
+        return {
+            model: providerConfig.teacher.model,
+            enabled,
+            healthy: null,
+            stale: null,
+            idle: null,
+            latestCycle,
+            detail: `${providerConfig.teacher.model} is enabled on Ollama, but no watch teacher snapshot is visible yet`
+        };
+    }
+    const stale = report.teacherLoop.latestFreshness === "stale" || report.teacherLoop.watchState === "stale_snapshot";
+    const idle = report.teacherLoop.running === false &&
+        (report.teacherLoop.queueDepth ?? 0) === 0 &&
+        report.teacherLoop.failureMode === "none";
+    const healthy = report.teacherLoop.failureMode === "none" &&
+        stale === false &&
+        report.teacherLoop.watchState !== "not_visible";
+    const cycleDetail = TEACHER_NO_OP_MESSAGES[report.teacherLoop.lastNoOpReason] ?? "the latest teacher cycle detail is unavailable";
+    if (report.teacherLoop.failureMode !== "none" && report.teacherLoop.failureMode !== "unavailable") {
+        return {
+            model: providerConfig.teacher.model,
+            enabled,
+            healthy: false,
+            stale,
+            idle,
+            latestCycle,
+            detail: report.teacherLoop.failureDetail === null
+                ? `${providerConfig.teacher.model} is enabled, but the watch loop recorded ${report.teacherLoop.failureMode}`
+                : `${providerConfig.teacher.model} is enabled, but the watch loop recorded ${report.teacherLoop.failureMode}: ${report.teacherLoop.failureDetail}`
+        };
+    }
+    return {
+        model: providerConfig.teacher.model,
+        enabled,
+        healthy,
+        stale,
+        idle,
+        latestCycle,
+        detail: `${providerConfig.teacher.model} is enabled on Ollama; ${cycleDetail}`
+    };
+}
+function summarizeStatusEmbedder(embeddings) {
+    const provisioned = embeddings.provisionedState === "confirmed" || embeddings.provisionedState === "builtin"
+        ? true
+        : embeddings.provisionedState === "not_confirmed" || embeddings.provisionedState === "off"
+            ? false
+            : null;
+    const live = embeddings.liveState === "yes" ? true : embeddings.liveState === "no" ? false : null;
+    if (embeddings.provider === "off") {
+        return {
+            model: embeddings.model,
+            provisioned,
+            live,
+            detail: `${embeddings.model} is not provisioned because the embedder provider is off`
+        };
+    }
+    if (embeddings.provider === "keywords") {
+        return {
+            model: embeddings.model,
+            provisioned,
+            live,
+            detail: "keyword embeddings are builtin, so there is no Ollama model to provision"
+        };
+    }
+    if (provisioned === true && live === true) {
+        return {
+            model: embeddings.model,
+            provisioned,
+            live,
+            detail: `${embeddings.model} is confirmed on Ollama and the active pack stores live numeric embeddings`
+        };
+    }
+    if (provisioned === true && live === false) {
+        return {
+            model: embeddings.model,
+            provisioned,
+            live,
+            detail: `${embeddings.model} is confirmed on Ollama, but the active pack still has no live numeric embeddings`
+        };
+    }
+    if (provisioned === false && live === true) {
+        return {
+            model: embeddings.model,
+            provisioned,
+            live,
+            detail: `${embeddings.model} is not confirmed on Ollama, but the active pack already carries numeric embeddings from an earlier materialization`
+        };
+    }
+    return {
+        model: embeddings.model,
+        provisioned,
+        live,
+        detail: embeddings.detail
+    };
+}
+function summarizeStatusRouteFn(status, report) {
+    const freshness = report.servePath.refreshStatus ?? status.brain.routeFreshness;
+    if (!report.routeFn.available) {
+        return {
+            available: false,
+            freshness,
+            trainedAt: report.routeFn.trainedAt,
+            updatedAt: report.routeFn.updatedAt,
+            usedAt: report.routeFn.usedAt,
+            detail: report.routeFn.detail
+        };
+    }
+    let detail = report.routeFn.detail;
+    if (report.servePath.usedLearnedRouteFn === true) {
+        detail = `current serve proof used the learned route_fn; ${report.routeFn.detail}`;
+    }
+    else if (report.routeFn.usedAt !== null) {
+        detail = `current serve proof did not use the learned route_fn, but the active route_fn last served a learned turn at ${report.routeFn.usedAt}`;
+    }
+    else if (report.routeFn.updatedAt !== null) {
+        detail = `active route_fn was last updated at ${report.routeFn.updatedAt}, but no learned serve use is visible yet for the current pack`;
+    }
+    return {
+        available: true,
+        freshness,
+        trainedAt: report.routeFn.trainedAt,
+        updatedAt: report.routeFn.updatedAt,
+        usedAt: report.routeFn.usedAt,
+        detail
+    };
+}
 function pushUniqueAlert(target, value) {
     const normalized = value.trim();
     if (normalized.length === 0) {
@@ -698,11 +1177,8 @@ function summarizeStatusAlerts(report, providerConfig, embeddings, localLlm) {
     }
     return buckets;
 }
-function summarizeStatusWatchState(report) {
-    if (!report.teacherLoop.available || report.teacherLoop.sourceKind !== "watch_snapshot") {
-        return "not_visible";
-    }
-    return report.teacherLoop.running === true ? "running" : "snapshot_only";
+function summarizeStatusWatchState(status) {
+    return status.passiveLearning.watchState;
 }
 function summarizeStatusServeReality(status) {
     if (status.brainStatus.serveState === "serving_active_pack") {
@@ -710,48 +1186,128 @@ function summarizeStatusServeReality(status) {
     }
     return status.brainStatus.serveState;
 }
+function summarizeStatusPromotionState(status) {
+    if (status.brain.state === "pg_promoted_pack_authoritative") {
+        return "promoted";
+    }
+    if (status.brain.state === "seed_state_authoritative") {
+        return status.passiveLearning.firstExportOccurred ? "seed_authoritative" : "awaiting_first_export";
+    }
+    return status.brain.state;
+}
 function formatStatusAlertLine(values) {
     const normalized = values.map((value) => value.trim()).filter((value) => value.length > 0);
     return normalized.length === 0 ? "none" : formatCompactList(normalized, 2, 64);
 }
-function summarizeStatusStartupToken(status) {
-    if (status.attachment.state !== "attached") {
-        return "BRAIN_NOT_YET_LOADED";
-    }
-    if (status.brainStatus.activationState === "broken_install" || status.brainStatus.activationState === "stale_incomplete" || status.brainStatus.activationState === "detached") {
-        return "BRAIN_NOT_YET_LOADED";
+function formatStatusNullableNumber(value, unknown = "unknown") {
+    return value === null ? unknown : String(value);
+}
+function formatStatusNullableYesNo(value) {
+    return value === null ? "unknown" : yesNo(value);
+}
+function formatStatusNullableMilliseconds(value) {
+    return value === null ? "none" : `${value.toFixed(2)}ms`;
+}
+function formatStatusHotPathTiming(timing) {
+    return [
+        `hotPath=${formatStatusNullableMilliseconds(timing.totalMs)}`,
+        `route=${formatStatusNullableMilliseconds(timing.routeSelectionMs)}`,
+        `prompt=${formatStatusNullableMilliseconds(timing.promptAssemblyMs)}`,
+        `other=${formatStatusNullableMilliseconds(timing.otherMs)}`,
+        `background=${timing.backgroundWorkIncluded ? "included" : "excluded"}`
+    ].join(" ");
+}
+function formatStatusObservedDeltaTransition(delta) {
+    if (delta.latestPackTransition === null) {
+        return "none";
     }
-    return status.brainStatus.serveState === "serving_active_pack" ? "BRAIN_LOADED" : "BRAIN_NOT_YET_LOADED";
+    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);
     const embeddings = summarizeStatusEmbeddings(report, options.providerConfig);
     const localLlm = summarizeStatusLocalLlm(options.providerConfig);
+    const teacher = summarizeStatusTeacher(report, options.providerConfig, localLlm);
+    const embedder = summarizeStatusEmbedder(embeddings);
+    const routeFn = summarizeStatusRouteFn(status, report);
     const alerts = summarizeStatusAlerts(report, options.providerConfig, embeddings, localLlm);
-    const promoted = status.brain.state === "pg_promoted_pack_authoritative" ? "yes" : "no";
     const liveModels = embeddings.models.length === 0 ? "none" : embeddings.models.join("|");
+    const attachmentTruth = summarizeStatusAttachmentTruth({
+        activationRoot: status.host.activationRoot,
+        openclawHome: options.openclawHome,
+        status
+    });
     return [
-        `reality     hook=${installHook.state} attach=${status.attachment.state} watch=${summarizeStatusWatchState(report)} promoted=${promoted} serve=${summarizeStatusServeReality(status)}`,
-        `startup     ${summarizeStatusStartupToken(status)} init=${status.brainStatus.activationState} proof=status_probe`,
+        `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)}`,
+        `delta       observed=${status.passiveLearning.lastObservedDelta.observedAt ?? "none"} exported=${formatStatusNullableYesNo(status.passiveLearning.lastObservedDelta.exported)} labeled=${formatStatusNullableYesNo(status.passiveLearning.lastObservedDelta.labeled)} promoted=${formatStatusNullableYesNo(status.passiveLearning.lastObservedDelta.promoted)} served=${formatStatusNullableYesNo(status.passiveLearning.lastObservedDelta.served)} transition=${formatStatusObservedDeltaTransition(status.passiveLearning.lastObservedDelta)}`,
+        `changed     ${status.passiveLearning.lastObservedDelta.explanation}`,
         `explain     ${status.brain.summary}`,
+        `graph       blocks=${report.graph.blockCount ?? "none"} strongest=${report.graph.strongestBlockId ?? "none"} latest=${report.graph.latestMaterialization.packId ?? "none"} latestChanged=${yesNo(report.graph.latestMaterialization.changed)} connect=${formatCompactGraphConnectDiagnostics(report.graph.latestMaterialization.connectDiagnostics ?? report.graph.connectDiagnostics)}`,
+        `teacher     model=${teacher.model} enabled=${yesNo(teacher.enabled)} healthy=${yesNo(teacher.healthy)} stale=${yesNo(teacher.stale)} idle=${yesNo(teacher.idle)} cycle=${teacher.latestCycle} why=${teacher.detail}`,
+        `embedder    model=${embedder.model} provisioned=${yesNo(embedder.provisioned)} live=${yesNo(embedder.live)} why=${embedder.detail}`,
+        `routeFn     available=${yesNo(routeFn.available)} freshness=${routeFn.freshness} trained=${routeFn.trainedAt ?? "none"} updated=${routeFn.updatedAt ?? "none"} used=${routeFn.usedAt ?? "none"} why=${routeFn.detail}`,
         `embeddings  provider=${embeddings.provider} provisioned=${embeddings.provisionedState} live=${embeddings.liveState} stored=${embeddings.embeddedEntryCount ?? "none"}/${embeddings.totalEntryCount ?? "none"} models=${liveModels}`,
         `localLLM    detected=${yesNo(localLlm.detected)} enabled=${yesNo(localLlm.enabled)} provider=${localLlm.provider} model=${localLlm.model}`,
         `alerts      service_risk=${formatStatusAlertLine(alerts.serviceRisk)} degraded_brain=${formatStatusAlertLine(alerts.degradedBrain)} cosmetic_noise=${formatStatusAlertLine(alerts.cosmeticNoise)}`
     ];
 }
 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"}`,
@@ -760,13 +1316,17 @@ function formatCurrentProfileStatusSummary(status, report, targetInspection, opt
         `budget      requested=${report.servePath.requestedBudgetStrategy ?? "none"} resolved=${report.servePath.resolvedBudgetStrategy ?? "none"} maxBlocks=${report.servePath.resolvedMaxContextBlocks ?? "none"} source=${report.servePath.structuralBudgetSource ?? "none"} origin=${status.brainStatus.structuralDecision.origin} basis=${status.brainStatus.structuralDecision.basis}`,
         `decision    ${status.brainStatus.structuralDecision.detail}`,
         `principal   latest=${formatPrincipalLatest(report)} pending=${report.principal.pendingCount ?? report.learning.pendingPrincipalCount ?? "none"} checkpoint=${formatPrincipalCheckpointFrontier(report)} downstream=${yesNo(report.principal.servingDownstreamOfLatestCorrection)} lag=${report.learning.principalLagToPromotion.sequenceLag ?? "none"}`,
+        `passive     learner=${yesNo(status.passiveLearning.learnerRunning)} firstExport=${yesNo(status.passiveLearning.firstExportOccurred)} watch=${status.passiveLearning.watchState} export=${status.passiveLearning.exportState} backlog=${status.passiveLearning.backlogState} pending=${formatStatusNullableNumber(status.passiveLearning.pendingLive)}/${formatStatusNullableNumber(status.passiveLearning.pendingBackfill)} detail=${status.passiveLearning.detail}`,
+        `delta       observed=${status.passiveLearning.lastObservedDelta.observedAt ?? "none"} exported=${formatStatusNullableYesNo(status.passiveLearning.lastObservedDelta.exported)} labeled=${formatStatusNullableYesNo(status.passiveLearning.lastObservedDelta.labeled)} promoted=${formatStatusNullableYesNo(status.passiveLearning.lastObservedDelta.promoted)} served=${formatStatusNullableYesNo(status.passiveLearning.lastObservedDelta.served)} transition=${formatStatusObservedDeltaTransition(status.passiveLearning.lastObservedDelta)} detail=${status.passiveLearning.lastObservedDelta.explanation}`,
         `scanner     flowing=${yesNo(report.supervision.flowing)} scan=${report.supervision.scanPolicy ?? "none"} surfaces=${formatScannerSurfaces(report)} labels=${report.supervision.humanLabelCount ?? "none"}/${report.supervision.selfLabelCount ?? "none"} attributable=${report.supervision.attributedEventCount ?? "none"}/${report.supervision.totalEventCount ?? "none"} digests=${report.supervision.selectionDigestCount ?? "none"}`,
         `labels      ${formatLabelFlowSummary(report.labelFlow)}`,
-        `graph       source=${report.graph.runtimePlasticitySource ?? "none"} ops=${formatStructuralOps(report)} changed=${yesNo(report.graph.changed)} pruned=${report.graph.prunedBlockCount ?? "none"} strongest=${report.graph.strongestBlockId ?? "none"} summary=${report.graph.operatorSummary ?? report.graph.detail}`,
+        `graph       source=${report.graph.runtimePlasticitySource ?? "none"} blocks=${report.graph.blockCount ?? "none"} strongest=${report.graph.strongestBlockId ?? "none"} ops=${formatStructuralOps(report)} latest=${report.graph.latestMaterialization.packId ?? "none"} latestChanged=${yesNo(report.graph.latestMaterialization.changed)} connect=${formatGraphConnectDiagnostics(report.graph.latestMaterialization.connectDiagnostics ?? report.graph.connectDiagnostics)} summary=${formatGraphSummary(report)}`,
         `path        ${formatLearningPathSummary(report.learningPath)}`,
         `learning    state=${report.learning.backlogState} bootstrapped=${yesNo(report.learning.bootstrapped)} mode=${report.learning.mode} next=${report.learning.nextPriorityLane} priority=${report.learning.nextPriorityBucket} pending=${report.learning.pendingLive ?? "none"}/${report.learning.pendingBackfill ?? "none"} buckets=${formatLearningBuckets(report)} warn=${formatLearningWarnings(report)} lastPack=${report.learning.lastMaterializedPackId ?? "none"} detail=${report.learning.detail}`,
-        `teacher     ${formatTeacherLoopSummary(report)}`,
-        `passive     cadence=${report.teacherLoop.learningCadence} scan=${report.teacherLoop.scanPolicy} slices=${report.teacherLoop.liveSlicesPerCycle ?? "none"}/${report.teacherLoop.backfillSlicesPerCycle ?? "none"} replayed=${report.teacherLoop.replayedBundleCount ?? "none"}/${report.teacherLoop.replayedEventCount ?? "none"} exported=${report.teacherLoop.exportedBundleCount ?? "none"}/${report.teacherLoop.exportedEventCount ?? "none"} tail=${report.teacherLoop.sessionTailSessionsTracked ?? "none"}/${report.teacherLoop.sessionTailBridgedEventCount ?? "none"} tailState=${report.teacherLoop.localSessionTailNoopReason ?? "none"} lastJob=${report.teacherLoop.lastAppliedMaterializationJobId ?? "none"} lastPack=${report.teacherLoop.lastMaterializedPackId ?? "none"}`,
+        `teacherProof ${formatTeacherLoopSummary(report)}`,
+        `watch       cadence=${report.teacherLoop.learningCadence} scan=${report.teacherLoop.scanPolicy} heartbeat=${report.teacherLoop.lastHeartbeatAt ?? "none"} interval=${report.teacherLoop.pollIntervalSeconds ?? "none"} replayed=${report.teacherLoop.replayedBundleCount ?? "none"}/${report.teacherLoop.replayedEventCount ?? "none"} exported=${report.teacherLoop.exportedBundleCount ?? "none"}/${report.teacherLoop.exportedEventCount ?? "none"} tail=${report.teacherLoop.sessionTailSessionsTracked ?? "none"}/${report.teacherLoop.sessionTailBridgedEventCount ?? "none"} tailState=${report.teacherLoop.localSessionTailNoopReason ?? "none"} lastJob=${report.teacherLoop.lastAppliedMaterializationJobId ?? "none"} lastPack=${report.teacherLoop.lastMaterializedPackId ?? "none"}`,
+        `embeddings  provider=${embeddings.provider} provisioned=${embeddings.provisionedState} live=${embeddings.liveState} stored=${embeddings.embeddedEntryCount ?? "none"}/${embeddings.totalEntryCount ?? "none"} models=${liveModels}`,
+        `localLLM    detected=${yesNo(localLlm.detected)} enabled=${yesNo(localLlm.enabled)} provider=${localLlm.provider} model=${localLlm.model}`,
         `rollback    ready=${yesNo(report.rollback.allowed)} state=${report.rollback.state} previous=${report.rollback.previousPackId ?? "none"}`,
         `proof       lastExport=${status.brain.lastExportAt ?? "none"} lastLearningUpdate=${status.brain.lastLearningUpdateAt ?? "none"} lastPromotion=${status.brain.lastPromotionAt ?? "none"}`,
         `logs        root=${status.brain.logRoot ?? "none"}`,
@@ -795,6 +1355,15 @@ function formatOpenClawTargetExplanation(inspection) {
 function buildInstallStatusCommand(activationRoot) {
     return `openclawbrain status --activation-root ${quoteShellArg(activationRoot)}`;
 }
+function buildLearnerServiceStatusCommand(activationRoot) {
+    return `openclawbrain daemon status --activation-root ${quoteShellArg(activationRoot)}`;
+}
+function buildGatewayRestartCommand(profileId) {
+    return `env -i HOME="$HOME" PATH="$PATH" openclaw --profile ${quoteShellArg(profileId)} gateway restart`;
+}
+function buildGatewayStatusCommand(profileId) {
+    return `env -i HOME="$HOME" PATH="$PATH" openclaw --profile ${quoteShellArg(profileId)} gateway status`;
+}
 function buildInstallCommand(openclawHome) {
     return `openclawbrain install --openclaw-home ${quoteShellArg(openclawHome)}`;
 }
@@ -978,6 +1547,12 @@ function writeInstallProviderDefaults(parsed) {
             : "Teacher: no compatible local Ollama model detected; watch stays heuristic unless explicitly overridden"
     };
 }
+function shouldWriteProfileHookProviderDefaults(parsed, activationPlan, isInstall) {
+    if (isInstall || activationPlan.action === "bootstrap") {
+        return true;
+    }
+    return !existsSync(resolveOpenClawBrainProviderDefaultsPath(parsed.activationRoot));
+}
 function buildInstallBrainFeedbackSummary(input) {
     const providerDefaultsPath = resolveOpenClawBrainProviderDefaultsPath(input.parsed.activationRoot);
     const embedderState = input.embedderProvision === null ? "unchanged" : input.embedderProvision.state;
@@ -985,15 +1560,61 @@ function buildInstallBrainFeedbackSummary(input) {
     const teacherProvider = teacherDefaults?.provider ?? "unknown";
     const teacherModel = teacherDefaults?.model ?? null;
     const detectedLocalLlm = teacherDefaults?.detectedLocally ?? null;
+    const profileName = input.targetInspection.profileId;
+    const profileSource = input.targetInspection.profileSource;
+    const casingGuidance = profileName === null
+        ? "Exact OpenClaw --profile casing is unresolved here because this target stays on the host-selected current_profile boundary."
+        : `Use the exact OpenClaw profile casing shown here for host-side restart/status commands: ${quoteShellArg(profileName)}.`;
+    const attachment = input.parsed.shared
+        ? {
+            policy: "shared",
+            activationRootMode: "shared_root_declared",
+            sameGatewayProof: "not_checked_in",
+            detail: "Shared activation root declared. Other profiles may point at this same root, but same-gateway many-profile load/serve proof is not checked in."
+        }
+        : {
+            policy: "dedicated",
+            activationRootMode: "dedicated_per_profile",
+            sameGatewayProof: "not_applicable",
+            detail: "Dedicated activation root for this profile/home boundary."
+        };
+    const restart = profileName === null
+        ? {
+            exactProfile: false,
+            profile: null,
+            profileSource,
+            guidance: `Operator-owned restart step: this install did not infer an exact --profile token from ${shortenPath(input.targetInspection.openclawHome)}. ` +
+                "If immediate load matters, restart the host-selected current_profile from OpenClaw itself; otherwise the next natural launch will pick up the hook.",
+            restartCommand: null,
+            gatewayStatusCommand: null
+        }
+        : {
+            exactProfile: true,
+            profile: profileName,
+            profileSource,
+            guidance: `Operator-owned restart step: if immediate load matters and profile ${quoteShellArg(profileName)} is already running, run ${buildGatewayRestartCommand(profileName)}. ` +
+                `If it is stopped, the next launch of profile ${quoteShellArg(profileName)} will pick up the hook. ${casingGuidance}`,
+            restartCommand: buildGatewayRestartCommand(profileName),
+            gatewayStatusCommand: buildGatewayStatusCommand(profileName)
+        };
     const provedNow = input.activationPlan.action === "bootstrap"
-        ? `hook written, activation root ready, seed/current-profile attach bootstrapped, provider defaults ${input.providerDefaults === null ? "kept" : "written"}`
-        : `hook written, activation root kept, active pack ${input.activationPlan.activePackId ?? "unknown"} preserved${input.providerDefaults === null ? "" : ", provider defaults written"}`;
-    const notYetProved = input.activationPlan.action === "bootstrap"
-        ? `OpenClaw has not reloaded this hook yet; restart plus status still must prove live startup/load and the first exported turn`
-        : `OpenClaw has not reloaded this hook yet; this ${input.parsed.command} run does not itself prove live startup/load after restart`;
+        ? `hook written, activation root ready, seed/current-profile attach bootstrapped, learner service ${input.learnerService.state}, provider defaults ${input.providerDefaults === null ? "kept" : "written"}`
+        : `hook written, activation root kept, active pack ${input.activationPlan.activePackId ?? "unknown"} preserved, learner service ${input.learnerService.state}${input.providerDefaults === null ? "" : ", provider defaults written"}`;
+    const notYetProved = input.learnerService.state === "deferred"
+        ? `OpenClaw has not reloaded this hook yet, and passive learner auto-start was deferred; restart plus status still must prove serve-path load, while learner-service start remains a separate operator check`
+        : input.activationPlan.action === "bootstrap"
+            ? `Passive learning is wired for this activation root, but OpenClaw has not reloaded the hook yet; restart plus status still must prove live startup/load and the first exported turn`
+            : `Passive learning is wired for this activation root, but this ${input.parsed.command} run does not itself prove live startup/load after restart`;
     return {
         hookPath: input.extensionDir,
         providerDefaultsPath,
+        profile: {
+            exactProfileName: profileName,
+            profileSource,
+            casingGuidance
+        },
+        attachment,
+        restart,
         embedder: {
             provider: "ollama",
             model: DEFAULT_OLLAMA_EMBEDDING_MODEL,
@@ -1004,6 +1625,14 @@ function buildInstallBrainFeedbackSummary(input) {
             model: teacherModel,
             detectedLocalLlm
         },
+        learnerService: {
+            state: input.learnerService.state,
+            detail: input.learnerService.detail,
+            plistPath: input.learnerService.plistPath,
+            logPath: input.learnerService.logPath,
+            configuredActivationRoot: input.learnerService.configuredActivationRoot,
+            matchesRequestedActivationRoot: input.learnerService.matchesRequestedActivationRoot
+        },
         startup: {
             token: "BRAIN_NOT_YET_LOADED",
             proof: "restart_required"
@@ -1012,19 +1641,28 @@ function buildInstallBrainFeedbackSummary(input) {
         notYetProved,
         lines: [
             `target      ${formatOpenClawTargetLine(input.targetInspection)} source=${formatInstallOpenClawHomeSource(input.parsed.openclawHomeSource)}`,
+            profileName === null
+                ? "profile     exactName=unresolved selector=current_profile casing=not_available"
+                : `profile     exactName=${quoteShellArg(profileName)} source=${profileSource} casing=preserved`,
             `hook        written=${shortenPath(input.extensionDir)}`,
             `activation  root=${shortenPath(input.parsed.activationRoot)} source=${formatInstallActivationRootSource(input.parsed.activationRootSource)}`,
+            `attachment  policy=${attachment.policy} rootMode=${attachment.activationRootMode} sameGatewayProof=${attachment.sameGatewayProof} detail=${attachment.detail}`,
             `defaults    provider-defaults=${shortenPath(providerDefaultsPath)} state=${input.providerDefaults === null ? "unchanged" : "written"}`,
             `embedder    provider=ollama model=${DEFAULT_OLLAMA_EMBEDDING_MODEL} state=${embedderState}`,
             `teacher     provider=${teacherProvider} model=${teacherModel ?? "none"} localLLM=${detectedLocalLlm === null ? "unknown" : yesNo(detectedLocalLlm)}`,
+            `learner     state=${input.learnerService.state} detail=${input.learnerService.detail}`,
+            `restart     operator=manual exactProfile=${yesNo(restart.exactProfile)} command=${restart.restartCommand ?? "unavailable"}`,
             "startup     BRAIN_NOT_YET_LOADED proof=restart_required",
             `provedNow   ${provedNow}`,
             `notYet      ${notYetProved}`
         ]
     };
 }
-function buildInstallReloadGuidance() {
-    return "If this OpenClaw profile is currently running, restart it before expecting the new brain hook to load. If it is stopped, the next launch will pick it up.";
+function buildInstallReloadGuidance(input) {
+    if (input.targetInspection.profileId === null) {
+        return `Restart later from OpenClaw for the host-selected current_profile behind ${shortenPath(input.targetInspection.openclawHome)} if immediate load matters; this install did not infer an exact --profile token.`;
+    }
+    return `Restart now if immediate load matters: ${buildGatewayRestartCommand(input.targetInspection.profileId)}`;
 }
 const LEGACY_PROFILE_NOTE_FILENAMES = ["BRAIN.md", "brain.md"];
 const LEGACY_BRAIN_AGENTS_LINE = "5. Read `BRAIN.md` — your learning brain context";
@@ -1108,8 +1746,21 @@ function buildCleanupRestartGuidance(restart) {
     }
     return "If this OpenClaw profile is currently running, restart it before expecting the new hook state to take effect. If it is stopped, the next launch will pick it up.";
 }
-function buildStatusNextStep(status, report) {
+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.";
     }
@@ -1119,9 +1770,27 @@ function buildStatusNextStep(status, report) {
     if (status.brainStatus.status === "fail") {
         return `Run \`openclawbrain status --activation-root ${activationRootArg} --detailed\` before changing lifecycle state so the serve-path failure is explicit.`;
     }
+    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.";
+    }
     if (report.learning.warningStates.includes("principal_live_backlog") ||
         report.learning.warningStates.includes("active_pack_behind_latest_principal")) {
         return "A newer principal correction is still pending promotion; keep the current pack conservative until learner promotion lands.";
@@ -1132,14 +1801,19 @@ function buildStatusNextStep(status, report) {
     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)}`,
             `preflight   ${formatOpenClawTargetExplanation(targetInspection)}`
         ]),
-        `next        ${buildStatusNextStep(status, report)}`
+        `next        ${buildStatusNextStep(status, report, {
+            openclawHome: options.openclawHome,
+            installHook
+        })}`
     ];
     return lines.join("\n");
 }
@@ -2139,7 +2813,7 @@ function buildExtensionIndexTs(activationRoot) {
 function buildExtensionPackageJson() {
     const packageMetadata = readOpenClawPackageMetadata();
     return JSON.stringify({
-        name: "openclawbrain-extension",
+        name: "openclawbrain",
         version: packageMetadata.version,
         private: true,
         type: "module",
@@ -2242,6 +2916,67 @@ function buildHistoryEntry(record, slot, isActive) {
         current: isActive
     };
 }
+function ensureLifecycleLearnerService(activationRoot) {
+    const outcome = ensureManagedLearnerServiceForActivationRoot(activationRoot);
+    return {
+        state: outcome.state,
+        detail: outcome.detail,
+        plistPath: outcome.inspection.plistPath,
+        logPath: outcome.inspection.logPath,
+        configuredActivationRoot: outcome.inspection.configuredActivationRoot,
+        matchesRequestedActivationRoot: outcome.inspection.matchesRequestedActivationRoot
+    };
+}
+function resolveCleanupLearnerServiceOutcome(activationRoot, openclawHome) {
+    if (activationRoot === null) {
+        return {
+            state: "unresolved",
+            detail: "Learner service preservation is unresolved because the activation root could not be resolved from the installed profile hook.",
+            plistPath: null,
+            logPath: null,
+            configuredActivationRoot: null,
+            matchesRequestedActivationRoot: null
+        };
+    }
+    const remainingProfiles = findOtherInstalledHookReferencesForActivationRoot({
+        activationRoot,
+        excludingOpenClawHome: openclawHome
+    });
+    const partitioned = partitionSharedActivationRootHookReferences(remainingProfiles);
+    if (partitioned.attached.length > 0) {
+        const inspection = inspectManagedLearnerService(activationRoot);
+        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}.${halfAttachedNote}`,
+            plistPath: inspection.plistPath,
+            logPath: inspection.logPath,
+            configuredActivationRoot: inspection.configuredActivationRoot,
+            matchesRequestedActivationRoot: inspection.matchesRequestedActivationRoot
+        };
+    }
+    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}${halfAttachedNote}`,
+        plistPath: outcome.inspection.plistPath,
+        logPath: outcome.inspection.logPath,
+        configuredActivationRoot: outcome.inspection.configuredActivationRoot,
+        matchesRequestedActivationRoot: outcome.inspection.matchesRequestedActivationRoot
+    };
+}
 function formatInspectionFindings(findings) {
     return findings.join("; ");
 }
@@ -2438,11 +3173,11 @@ function runProfileHookAttachCommand(parsed) {
     }
     steps.push(activationPlan.inspectionStep);
     // 5. Persist install-written local provider defaults so watch/learning surfaces do not depend on gateway env wiring.
-    const providerDefaults = isInstall || activationPlan.action === "bootstrap"
+    const providerDefaults = shouldWriteProfileHookProviderDefaults(parsed, activationPlan, isInstall)
         ? writeInstallProviderDefaults(parsed)
         : null;
     if (providerDefaults === null) {
-        steps.push("Skipped provider-default refresh because explicit attach is reusing existing activation data.");
+        steps.push("Preserved existing provider-defaults.json because explicit attach is reusing existing activation data.");
     }
     else {
         steps.push(providerDefaults.detail);
@@ -2528,16 +3263,38 @@ function runProfileHookAttachCommand(parsed) {
     const manifestPath = path.join(extensionDir, "openclaw.plugin.json");
     writeFileSync(manifestPath, buildExtensionPluginManifest(), "utf8");
     steps.push(`Wrote manifest: ${manifestPath}`);
-    const restartGuidance = buildInstallReloadGuidance();
+    const pluginConfigRepair = ensureOpenClawBrainPluginConfig(parsed.openclawHome);
+    steps.push(pluginConfigRepair.detail);
+    const learnerService = ensureLifecycleLearnerService(parsed.activationRoot);
+    steps.push(learnerService.detail);
+    const brainFeedback = buildInstallBrainFeedbackSummary({
+        parsed,
+        targetInspection,
+        extensionDir,
+        activationPlan,
+        learnerService,
+        embedderProvision,
+        providerDefaults
+    });
+    const restartGuidance = buildInstallReloadGuidance({
+        targetInspection
+    });
     const nextSteps = [
         restartGuidance,
+        brainFeedback.restart.gatewayStatusCommand === null
+            ? null
+            : `Confirm gateway after restart: ${brainFeedback.restart.gatewayStatusCommand}`,
         `Check status: ${buildInstallStatusCommand(parsed.activationRoot)}`,
+        `Check learner service: ${buildLearnerServiceStatusCommand(parsed.activationRoot)}`,
         embedderProvision !== null && embedderProvision.state === "skipped"
             ? `Provision default embedder later: ${buildInstallEmbedderProvisionCommand(embedderProvision.baseUrl, embedderProvision.model)}`
             : null
     ].filter((step) => step !== null);
     const preflightSummary = [
         `Hook: installed at ${shortenPath(extensionDir)}`,
+        parsed.shared
+            ? "Attachment policy: shared activation root declared; same-gateway many-profile load/serve proof is still not checked in"
+            : "Attachment policy: dedicated activation root for this profile/home boundary",
         activationPlan.action === "bootstrap"
             ? "Attachment: seed/current-profile attach created; restart plus status will prove later serve-path use"
             : `Attachment: existing active pack ${activationPlan.activePackId} kept in place; restart plus status will prove later serve-path use`,
@@ -2546,6 +3303,7 @@ function runProfileHookAttachCommand(parsed) {
             : embedderProvision.state === "ensured"
                 ? `Embedder: default Ollama model ${embedderProvision.model} was ensured before bootstrap`
                 : `Embedder: default Ollama model ${embedderProvision.model} was intentionally skipped`,
+        `Learner: background service ${learnerService.state} for the exact activation root/profile boundary`,
         `Serve path: install alone does not prove serving; restart the profile and run ${buildInstallStatusCommand(parsed.activationRoot)}`
     ];
     const lifecycleSummary = [
@@ -2554,7 +3312,11 @@ function runProfileHookAttachCommand(parsed) {
             : "Lifecycle mode: attach (explicit reattach/manual profile hookup)",
         `OpenClaw target: ${shortenPath(parsed.openclawHome)} (${formatInstallOpenClawHomeSource(parsed.openclawHomeSource)})`,
         `Detected layout: ${formatOpenClawTargetExplanation(targetInspection)}`,
+        brainFeedback.profile.exactProfileName === null
+            ? "Profile token: current_profile only; this install did not infer an exact --profile token"
+            : `Profile token: use exact OpenClaw profile casing ${quoteShellArg(brainFeedback.profile.exactProfileName)} for host-side restart/status commands`,
         `Activation root: ${shortenPath(parsed.activationRoot)} (${formatInstallActivationRootSource(parsed.activationRootSource)})`,
+        `Attachment policy: ${brainFeedback.attachment.policy} (${brainFeedback.attachment.detail})`,
         `Workspace ID: ${parsed.workspaceId} (${formatInstallWorkspaceIdSource(parsed.workspaceIdSource)})`,
         embedderProvision === null
             ? "Embedder: unchanged because no bootstrap was needed"
@@ -2563,6 +3325,7 @@ function runProfileHookAttachCommand(parsed) {
                 : `Embedder: skipped default Ollama model ${embedderProvision.model} via ${parsed.skipEmbedderProvisionSource === "flag" ? "--skip-embedder-provision" : OPENCLAWBRAIN_INSTALL_SKIP_EMBEDDER_PROVISION_ENV}`,
         ...(providerDefaults === null ? [] : [`${providerDefaults.lifecycleSummary} (${shortenPath(providerDefaults.path)})`]),
         `Profile hook: installed at ${shortenPath(extensionDir)}`,
+        `Learner service: ${learnerService.state} for ${shortenPath(parsed.activationRoot)}`,
         activationPlan.resolution === "new_root"
             ? `Activation data: initialized at ${shortenPath(parsed.activationRoot)}`
             : activationPlan.resolution === "missing_pointers"
@@ -2580,14 +3343,6 @@ function runProfileHookAttachCommand(parsed) {
                 ? `Install: kept healthy active pack ${activationPlan.activePackId} in place`
                 : `Attach: rewired the profile hook to healthy active pack ${activationPlan.activePackId}`
     ];
-    const brainFeedback = buildInstallBrainFeedbackSummary({
-        parsed,
-        targetInspection,
-        extensionDir,
-        activationPlan,
-        embedderProvision,
-        providerDefaults
-    });
     // 9. Print summary
     if (parsed.json) {
         console.log(JSON.stringify({
@@ -2642,11 +3397,17 @@ function runProfileHookAttachCommand(parsed) {
                     teacherBaseUrl: providerDefaults.defaults.teacherBaseUrl ?? null,
                     embedderBaseUrl: providerDefaults.defaults.embedderBaseUrl ?? null
                 },
+            pluginConfigRepair,
+            learnerService,
             brainFeedback: {
                 hookPath: brainFeedback.hookPath,
                 providerDefaultsPath: brainFeedback.providerDefaultsPath,
+                profile: brainFeedback.profile,
+                attachment: brainFeedback.attachment,
+                restart: brainFeedback.restart,
                 embedder: brainFeedback.embedder,
                 teacher: brainFeedback.teacher,
+                learnerService: brainFeedback.learnerService,
                 startup: brainFeedback.startup,
                 provedNow: brainFeedback.provedNow,
                 notYetProved: brainFeedback.notYetProved,
@@ -2666,8 +3427,12 @@ function runProfileHookAttachCommand(parsed) {
         for (const line of brainFeedback.lines) {
             console.log(`  ${line}`);
         }
-        console.log(`Next:       ${restartGuidance}`);
+        console.log(`Restart:    ${restartGuidance}`);
+        if (brainFeedback.restart.gatewayStatusCommand !== null) {
+            console.log(`Gateway:    Confirm OpenClaw after restart: ${brainFeedback.restart.gatewayStatusCommand}`);
+        }
         console.log(`Check:      ${buildInstallStatusCommand(parsed.activationRoot)}`);
+        console.log(`Learner:    ${buildLearnerServiceStatusCommand(parsed.activationRoot)}`);
         if (embedderProvision !== null && embedderProvision.state === "skipped") {
             console.log(`Embedder:   ${buildInstallEmbedderProvisionCommand(embedderProvision.baseUrl, embedderProvision.model)}`);
         }
@@ -2689,6 +3454,125 @@ function validateOpenClawHome(openclawHome) {
         throw new Error(`openclaw.json not found in ${openclawHome}`);
     }
 }
+function readJsonObjectRecord(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    return value;
+}
+function readOpenClawJsonConfig(openclawHome) {
+    const openclawJsonPath = path.join(openclawHome, "openclaw.json");
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(openclawJsonPath, "utf8"));
+    }
+    catch (error) {
+        throw new Error(`Failed to read ${openclawJsonPath}: ${toErrorMessage(error)}`);
+    }
+    const config = readJsonObjectRecord(parsed);
+    if (config === null) {
+        throw new Error(`Failed to read ${openclawJsonPath}: openclaw.json must contain a top-level object`);
+    }
+    return {
+        path: openclawJsonPath,
+        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);
+    if (plugins === null) {
+        return {
+            path: openclawJsonPath,
+            changed: false,
+            detail: `No stale openclawbrain plugin config found in ${openclawJsonPath}`
+        };
+    }
+    const changes = [];
+    let changed = false;
+    if (Array.isArray(plugins.allow)) {
+        const filteredAllow = plugins.allow.filter((entry) => entry !== "openclawbrain");
+        if (filteredAllow.length !== plugins.allow.length) {
+            changed = true;
+            changes.push("removed plugins.allow entry");
+            if (filteredAllow.length > 0) {
+                plugins.allow = filteredAllow;
+            }
+            else {
+                delete plugins.allow;
+            }
+        }
+    }
+    const entries = readJsonObjectRecord(plugins.entries);
+    if (entries !== null && Object.prototype.hasOwnProperty.call(entries, "openclawbrain")) {
+        delete entries.openclawbrain;
+        changed = true;
+        changes.push("removed plugins.entries.openclawbrain");
+    }
+    if (entries !== null && Object.keys(entries).length === 0 && Object.prototype.hasOwnProperty.call(plugins, "entries")) {
+        delete plugins.entries;
+        changed = true;
+        changes.push("removed empty plugins.entries container");
+    }
+    if (Object.keys(plugins).length === 0 && Object.prototype.hasOwnProperty.call(config, "plugins")) {
+        delete config.plugins;
+        changed = true;
+        changes.push("removed empty plugins container");
+    }
+    if (changed) {
+        writeFileSync(openclawJsonPath, JSON.stringify(config, null, 2) + "\n", "utf8");
+        return {
+            path: openclawJsonPath,
+            changed: true,
+            detail: `Scrubbed stale openclawbrain plugin config in ${openclawJsonPath}: ${changes.join(", ")}`
+        };
+    }
+    return {
+        path: openclawJsonPath,
+        changed: false,
+        detail: `No stale openclawbrain plugin config found in ${openclawJsonPath}`
+    };
+}
 function resolveCleanupActivationRoot(openclawHome, explicitActivationRoot) {
     if (explicitActivationRoot !== null) {
         return path.resolve(explicitActivationRoot);
@@ -2726,12 +3610,32 @@ 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);
     const legacyResidue = removeLegacyProfileResidue(parsed.openclawHome);
     const activationData = summarizeKeptActivationData(activationRoot);
@@ -2739,14 +3643,17 @@ function runDetachCommand(parsed) {
     const nextSteps = [
         restartGuidance,
         activationRoot === null ? null : `Inspect preserved data: ${buildInstallStatusCommand(activationRoot)}`,
+        activationRoot === null ? null : `Inspect learner service: ${buildLearnerServiceStatusCommand(activationRoot)}`,
         `Reattach later: ${buildAttachCommand(parsed.openclawHome, activationRoot)}`
     ].filter((step) => step !== null);
+    steps.push(pluginConfigCleanup.detail);
     if (legacyResidue.removedNotes.length > 0) {
         steps.push(`Removed legacy profile notes: ${legacyResidue.removedNotes.map((notePath) => shortenPath(notePath)).join(", ")}`);
     }
     if (legacyResidue.updatedAgents.length > 0) {
         steps.push(`Removed legacy AGENTS.md brain references: ${legacyResidue.updatedAgents.map((agentsPath) => shortenPath(agentsPath)).join(", ")}`);
     }
+    steps.push(learnerService.detail);
     steps.push(activationData.activationDataDetail);
     steps.push("Detach only removes the OpenClaw profile hook; it does not delete OpenClawBrain data.");
     if (parsed.json) {
@@ -2764,6 +3671,8 @@ function runDetachCommand(parsed) {
             activationRoot,
             dataAction: "kept",
             activationDataState: activationData.activationDataState,
+            pluginConfigCleanup,
+            learnerService,
             removedLegacyNotes: legacyResidue.removedNotes,
             updatedAgents: legacyResidue.updatedAgents,
             restartMode: parsed.restart,
@@ -2786,9 +3695,12 @@ function runDetachCommand(parsed) {
         else {
             console.log("Brain data:    preserved, but the activation root could not be resolved from the removed hook.");
         }
+        console.log(`Config:        ${pluginConfigCleanup.detail}`);
+        console.log(`Learner:       ${learnerService.detail}`);
         console.log(`Next:          ${restartGuidance}`);
         if (activationRoot !== null) {
             console.log(`Check:         ${buildInstallStatusCommand(activationRoot)}`);
+            console.log(`Service:       ${buildLearnerServiceStatusCommand(activationRoot)}`);
         }
         console.log(`Reattach:      ${buildAttachCommand(parsed.openclawHome, activationRoot)}`);
     }
@@ -2800,6 +3712,21 @@ 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,
+            openclawHome: parsed.openclawHome
+        });
+    }
+    const learnerService = resolveCleanupLearnerServiceOutcome(activationRoot, parsed.openclawHome);
+    const pluginConfigCleanup = scrubOpenClawBrainPluginConfig(parsed.openclawHome);
+    if (parsed.dataMode === "purge" &&
+        activationRoot !== null &&
+        learnerService.state === "preserved" &&
+        learnerService.matchesRequestedActivationRoot !== false) {
+        throw new Error(`Refusing to purge activation root ${path.resolve(activationRoot)} because the background learner service for this exact root could not be removed. ${learnerService.detail}`);
+    }
     const extensionDir = removeProfileHookup(parsed.openclawHome, steps);
     const legacyResidue = removeLegacyProfileResidue(parsed.openclawHome);
     let activationData;
@@ -2830,16 +3757,19 @@ function runUninstallCommand(parsed) {
     const nextSteps = [
         restartGuidance,
         parsed.dataMode === "keep" && activationRoot !== null ? `Inspect preserved data: ${buildInstallStatusCommand(activationRoot)}` : null,
+        activationRoot === null ? null : `Inspect learner service: ${buildLearnerServiceStatusCommand(activationRoot)}`,
         parsed.dataMode === "keep"
             ? `Reattach later: ${buildAttachCommand(parsed.openclawHome, activationRoot)}`
             : `Reinstall later: ${buildInstallCommand(parsed.openclawHome)}`
     ].filter((step) => step !== null);
+    steps.push(pluginConfigCleanup.detail);
     if (legacyResidue.removedNotes.length > 0) {
         steps.push(`Removed legacy profile notes: ${legacyResidue.removedNotes.map((notePath) => shortenPath(notePath)).join(", ")}`);
     }
     if (legacyResidue.updatedAgents.length > 0) {
         steps.push(`Removed legacy AGENTS.md brain references: ${legacyResidue.updatedAgents.map((agentsPath) => shortenPath(agentsPath)).join(", ")}`);
     }
+    steps.push(learnerService.detail);
     steps.push(activationData.activationDataDetail);
     steps.push(parsed.dataMode === "purge"
         ? "Uninstall removed the OpenClaw profile hook and activation data."
@@ -2859,6 +3789,8 @@ function runUninstallCommand(parsed) {
             activationRoot,
             dataAction: parsed.dataMode,
             activationDataState: activationData.activationDataState,
+            pluginConfigCleanup,
+            learnerService,
             removedLegacyNotes: legacyResidue.removedNotes,
             updatedAgents: legacyResidue.updatedAgents,
             restartMode: parsed.restart,
@@ -2879,10 +3811,15 @@ function runUninstallCommand(parsed) {
         if (activationRoot !== null) {
             console.log(`Activation:    ${parsed.dataMode === "purge" ? shortenPath(activationRoot) : `${shortenPath(activationRoot)} preserved`}`);
         }
+        console.log(`Config:        ${pluginConfigCleanup.detail}`);
+        console.log(`Learner:       ${learnerService.detail}`);
         console.log(`Next:          ${restartGuidance}`);
         if (parsed.dataMode === "keep" && activationRoot !== null) {
             console.log(`Check:         ${buildInstallStatusCommand(activationRoot)}`);
         }
+        if (activationRoot !== null) {
+            console.log(`Service:       ${buildLearnerServiceStatusCommand(activationRoot)}`);
+        }
         if (parsed.dataMode === "keep") {
             console.log(`Reattach:      ${buildAttachCommand(parsed.openclawHome, activationRoot)}`);
         }
@@ -3454,13 +4391,62 @@ function exportLocalSessionTailChangesToScanRoot(input) {
         warnings
     };
 }
-function applyWatchMaterialization(activationRoot, snapshot, lastHandledMaterializationPackId) {
-    const materialization = snapshot?.learner?.lastMaterialization ?? null;
+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
+    };
+}
+function buildWatchEmbedTracePoint(input) {
+    const summary = summarizeVectorEmbeddingState(input.vectors);
+    return {
+        slot: input.slot,
+        packId: input.packId,
+        runtimeEmbedderPresent: input.embedder !== null,
+        runtimeEmbedderModel: input.embedder?.model ?? null,
+        vectorEntryCount: summary.vectorEntryCount,
+        numericEmbeddingEntryCount: summary.numericEmbeddingEntryCount,
+        embeddingModels: summary.embeddingModels,
+        error: input.error ?? null
+    };
+}
+function buildWatchEmbedTracePointFromPack(input) {
+    return buildWatchEmbedTracePoint({
+        slot: input.slot,
+        packId: input.pack?.manifest.packId ?? null,
+        embedder: input.embedder,
+        vectors: input.pack?.vectors,
+        error: input.error ?? null
+    });
+}
+function formatWatchEmbedTracePoint(label, point) {
+    const models = point.embeddingModels.length === 0 ? "none" : point.embeddingModels.join("|");
+    const slot = point.slot ?? "build";
+    const packId = point.packId ?? "unknown";
+    const embedderState = point.runtimeEmbedderPresent ? `present:${point.runtimeEmbedderModel ?? "unknown"}` : "null";
+    const counts = point.vectorEntryCount === null || point.numericEmbeddingEntryCount === null
+        ? "vectors=unknown numeric=unknown"
+        : `vectors=${point.vectorEntryCount} numeric=${point.numericEmbeddingEntryCount}`;
+    const error = point.error === null ? "" : ` error=${point.error}`;
+    return `embed-trace ${label} slot=${slot} pack=${packId} runtimeEmbedder=${embedderState} ${counts} models=${models}${error}`;
+}
+async function applyWatchMaterialization(activationRoot, snapshot, lastHandledMaterializationPackId, embedder, log) {
+    let materialization = snapshot?.learner?.lastMaterialization ?? null;
     if (materialization === null) {
         return {
             lastHandledMaterializationPackId,
             logLine: null,
             materializedPackId: null,
+            embedInstrumentation: null,
             failure: null
         };
     }
@@ -3472,10 +4458,38 @@ function applyWatchMaterialization(activationRoot, snapshot, lastHandledMaterial
             lastHandledMaterializationPackId,
             logLine: null,
             materializedPackId: packId,
+            embedInstrumentation: null,
             failure: null
         };
     }
+    if (embedder !== null) {
+        materialization = {
+            ...materialization,
+            candidate: await reindexCandidatePackBuildResultWithEmbedder(materialization.candidate, embedder)
+        };
+        if (snapshot?.learner !== undefined && snapshot.learner !== null) {
+            snapshot.learner.lastMaterialization = materialization;
+        }
+    }
     const shortPackId = packId.length > 16 ? packId.slice(0, 16) : packId;
+    const observedAt = new Date().toISOString();
+    const beforeCandidateMaterialization = buildWatchEmbedTracePoint({
+        slot: null,
+        packId,
+        embedder,
+        vectors: materialization?.candidate?.payloads?.vectors
+    });
+    let embedInstrumentation = {
+        observedAt,
+        candidatePackId: packId,
+        promotionAllowed: null,
+        promotionFindings: [],
+        beforeCandidateMaterialization,
+        afterCandidateMaterialization: null,
+        afterStage: null,
+        afterPromote: null
+    };
+    log?.(formatWatchEmbedTracePoint("before_materialize", beforeCandidateMaterialization));
     try {
         const candidateRootDir = path.resolve(activationRoot, "packs", packId);
         mkdirSync(candidateRootDir, { recursive: true });
@@ -3487,27 +4501,81 @@ function applyWatchMaterialization(activationRoot, snapshot, lastHandledMaterial
             activeBeforePack = null;
         }
         const candidateDescriptor = materializeAlwaysOnLearningCandidatePack(candidateRootDir, materialization);
+        embedInstrumentation = {
+            ...embedInstrumentation,
+            afterCandidateMaterialization: buildWatchEmbedTracePointFromPack({
+                slot: "candidate",
+                pack: candidateDescriptor,
+                embedder
+            })
+        };
+        if (embedInstrumentation.afterCandidateMaterialization !== null) {
+            log?.(formatWatchEmbedTracePoint("after_materialize", embedInstrumentation.afterCandidateMaterialization));
+        }
         appendLearningUpdateLogs({
             activationRoot,
             materialization,
             activeBeforePack,
             candidateDescriptor
         });
-        const now = new Date().toISOString();
+        const now = observedAt;
         stageCandidatePack(activationRoot, candidateRootDir, {
             updatedAt: now,
             reason: `watch_stage:${materialization.reason}:${materialization.lane}`
         });
         const inspection = inspectActivationState(activationRoot, now);
+        let stagedPack = null;
+        let stagedPackError = null;
+        try {
+            stagedPack = loadPackFromActivation(activationRoot, "candidate", { requireActivationReady: true });
+        }
+        catch (error) {
+            stagedPackError = formatWatchError(error);
+        }
+        embedInstrumentation = {
+            ...embedInstrumentation,
+            promotionAllowed: inspection.promotion.allowed,
+            promotionFindings: [...inspection.promotion.findings],
+            afterStage: buildWatchEmbedTracePointFromPack({
+                slot: "candidate",
+                pack: stagedPack,
+                embedder,
+                error: stagedPackError
+            })
+        };
+        if (embedInstrumentation.afterStage !== null) {
+            log?.(formatWatchEmbedTracePoint("after_stage", embedInstrumentation.afterStage));
+        }
         if (inspection.promotion.allowed) {
             promoteCandidatePack(activationRoot, {
                 updatedAt: now,
                 reason: `watch_promote:${materialization.reason}:${materialization.lane}`
             });
+            let promotedPack = null;
+            let promotedPackError = null;
+            try {
+                promotedPack = loadPackFromActivation(activationRoot, "active", { requireActivationReady: true });
+            }
+            catch (error) {
+                promotedPackError = formatWatchError(error);
+            }
+            embedInstrumentation = {
+                ...embedInstrumentation,
+                afterPromote: buildWatchEmbedTracePointFromPack({
+                    slot: "active",
+                    pack: promotedPack,
+                    embedder,
+                    error: promotedPackError
+                })
+            };
+            if (embedInstrumentation.afterPromote !== null) {
+                log?.(formatWatchEmbedTracePoint("after_promote", embedInstrumentation.afterPromote));
+            }
             return {
                 lastHandledMaterializationPackId: packId,
                 materializedPackId: packId,
                 logLine: `Promoted ${shortPackId} → active`,
+                embedInstrumentation,
                 failure: null
             };
         }
@@ -3515,15 +4583,28 @@ function applyWatchMaterialization(activationRoot, snapshot, lastHandledMaterial
             lastHandledMaterializationPackId: packId,
             materializedPackId: packId,
             logLine: `Staged ${shortPackId} (promotion blocked: ${inspection.promotion.findings.join(", ")})`,
+            embedInstrumentation,
             failure: null
         };
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
+        embedInstrumentation = {
+            ...embedInstrumentation,
+            afterCandidateMaterialization: embedInstrumentation.afterCandidateMaterialization ??
+                buildWatchEmbedTracePoint({
+                    slot: "candidate",
+                    packId,
+                    embedder,
+                    vectors: null,
+                    error: message
+                })
+        };
         return {
             lastHandledMaterializationPackId,
             materializedPackId: packId,
             logLine: `Promotion failed for ${shortPackId}: ${message}`,
+            embedInstrumentation,
             failure: {
                 mode: "materialization_failed",
                 detail: message,
@@ -3569,12 +4650,178 @@ function resolveWatchTeacherLabelerConfig(input, activationRoot) {
         warnings
     };
 }
+function resolveWatchEmbedderConfig(input, activationRoot) {
+    if (input !== undefined) {
+        return {
+            embedder: input,
+            warnings: []
+        };
+    }
+    const defaultsResult = readOpenClawBrainProviderDefaults(activationRoot);
+    const providerConfig = readOpenClawBrainProviderConfigFromSources({
+        env: process.env,
+        activationRoot,
+        defaults: defaultsResult.defaults
+    });
+    const warnings = [...new Set([
+            ...defaultsResult.warnings.filter((warning) => /OPENCLAWBRAIN_EMBEDDER_|provider defaults/u.test(warning)),
+            ...providerConfig.warnings.filter((warning) => /OPENCLAWBRAIN_EMBEDDER_|provider defaults/u.test(warning))
+        ])];
+    const explicitEnv = typeof process.env[OPENCLAWBRAIN_EMBEDDER_PROVIDER_ENV] === "string" ||
+        typeof process.env[OPENCLAWBRAIN_EMBEDDER_MODEL_ENV] === "string" ||
+        typeof process.env[OPENCLAWBRAIN_EMBEDDER_BASE_URL_ENV] === "string";
+    // Legacy install-written provider-defaults.json files can predate embedder fields entirely.
+    // If a persisted defaults file exists, treat that activation root as explicitly configured and
+    // let provider-config resolution fill in the embedder fallback instead of silently dropping to null.
+    const explicitDefaults = defaultsResult.defaults !== null;
+    if (!explicitEnv && !explicitDefaults) {
+        return {
+            embedder: null,
+            warnings
+        };
+    }
+    if (providerConfig.embedder.provider !== "ollama") {
+        return {
+            embedder: null,
+            warnings
+        };
+    }
+    return {
+        embedder: createOllamaEmbedder({
+            baseUrl: providerConfig.embedderBaseUrl,
+            model: providerConfig.embedder.model
+        }),
+        warnings
+    };
+}
+function summarizeWatchLatestUserMessage(localPoll) {
+    let latest = null;
+    for (const change of localPoll.changes) {
+        if (change.lastUserMessageAt === null || change.lastUserMessageText === null) {
+            continue;
+        }
+        const candidate = {
+            at: change.lastUserMessageAt,
+            text: change.lastUserMessageText,
+            sessionId: change.sessionId
+        };
+        if (latest === null || Date.parse(candidate.at) >= Date.parse(latest.at)) {
+            latest = candidate;
+        }
+    }
+    return latest;
+}
+function summarizeWatchPackTransition(input) {
+    const beforeActivePackId = input.before?.active?.packId ?? input.before?.pointers.active?.packId ?? null;
+    const afterActivePackId = input.after?.active?.packId ?? input.after?.pointers.active?.packId ?? null;
+    if (afterActivePackId !== null && beforeActivePackId !== afterActivePackId) {
+        return {
+            kind: "promoted_active",
+            fromPackId: beforeActivePackId,
+            toPackId: afterActivePackId
+        };
+    }
+    const beforeCandidatePackId = input.before?.candidate?.packId ?? input.before?.pointers.candidate?.packId ?? null;
+    const afterCandidatePackId = input.after?.candidate?.packId ?? input.after?.pointers.candidate?.packId ?? null;
+    if (afterCandidatePackId !== null && beforeCandidatePackId !== afterCandidatePackId) {
+        return {
+            kind: "staged_candidate",
+            fromPackId: beforeCandidatePackId,
+            toPackId: afterCandidatePackId
+        };
+    }
+    return null;
+}
+function truncateWatchMessage(text, maxLength = 96) {
+    const normalized = text.replace(/\s+/gu, " ").trim();
+    if (normalized.length <= maxLength) {
+        return normalized;
+    }
+    return `${normalized.slice(0, maxLength - 1)}…`;
+}
+function buildWatchLastObservedDelta(input) {
+    const exported = input.exported.exportedBundleCount > 0 ||
+        input.exported.exportedEventCount > 0;
+    const labeled = (input.snapshotAfter.diagnostics.emittedArtifactCount ?? 0) >
+        (input.snapshotBefore.diagnostics.emittedArtifactCount ?? 0);
+    const latestPackTransition = summarizeWatchPackTransition({
+        before: input.beforeInspection,
+        after: input.afterInspection
+    });
+    const promoted = latestPackTransition?.kind === "promoted_active";
+    const afterActivePackId = input.afterInspection?.active?.packId ?? input.afterInspection?.pointers.active?.packId ?? null;
+    const served = promoted && afterActivePackId === latestPackTransition?.toPackId && input.afterInspection?.active?.activationReady === true;
+    const latestUserMessage = summarizeWatchLatestUserMessage(input.localPoll);
+    const selectedBackfillOnly = !exported && input.scanResult.selected.length > 0;
+    const cycleDidNothing = !exported && !labeled && !promoted && !served;
+    let explanation;
+    if (latestUserMessage === null) {
+        if (selectedBackfillOnly) {
+            explanation =
+                "No new local user message was exported in this cycle; the learner only revisited stored exports, so this pass does not prove a new last-turn change.";
+        }
+        else if (cycleDidNothing) {
+            explanation = "No new local user message or learner-visible export was observed in this cycle, so nothing changed.";
+        }
+        else if (promoted && latestPackTransition !== null) {
+            explanation =
+                `No new local user message was exported in this cycle; pack ${latestPackTransition.toPackId} moved into ${latestPackTransition.kind === "promoted_active" ? "active serving" : "the candidate slot"} from previously accumulated learner state.`;
+        }
+        else {
+            explanation =
+                "This cycle observed learner activity, but it did not include a new local user message, so the latest last-turn delta cannot be attributed to a fresh user turn.";
+        }
+    }
+    else {
+        const quotedMessage = `"${truncateWatchMessage(latestUserMessage.text)}"`;
+        if (exported && labeled && promoted && served && latestPackTransition !== null) {
+            explanation =
+                `Latest user message ${quotedMessage} was exported, labeled, promoted into pack ${latestPackTransition.toPackId}, and is now served from the active pack.`;
+        }
+        else if (exported && labeled && !promoted) {
+            explanation =
+                `Latest user message ${quotedMessage} was exported and labeled, but it has not been promoted into the serving pack yet.`;
+        }
+        else if (exported && !labeled && !promoted) {
+            explanation =
+                `Latest user message ${quotedMessage} was exported, but it did not add a new teacher label or change the serving pack in this cycle.`;
+        }
+        else if (exported && !labeled && promoted && latestPackTransition !== null) {
+            explanation =
+                `Latest user message ${quotedMessage} was exported, but this cycle's promotion to pack ${latestPackTransition.toPackId} is not backed by a new teacher label from that message alone.`;
+        }
+        else if (!exported && labeled) {
+            explanation =
+                `Latest user message ${quotedMessage} was already in stored exports; this cycle only labeled or replayed it, without a new local export.`;
+        }
+        else if (cycleDidNothing) {
+            explanation = `Latest user message ${quotedMessage} did not produce a new export, label, or serving-pack change in this cycle.`;
+        }
+        else {
+            explanation =
+                `Latest user message ${quotedMessage} changed learner state this cycle, but the local artifacts do not prove a clean export-to-serve handoff yet.`;
+        }
+    }
+    return {
+        available: true,
+        observedAt: input.observedAt,
+        exported,
+        labeled,
+        promoted,
+        served,
+        latestPackTransition,
+        explanation
+    };
+}
 export async function createWatchCommandRuntime(input) {
     const activationRoot = path.resolve(input.activationRoot);
     const bootstrapObservedAt = new Date().toISOString();
     const scanRoot = input.scanRoot !== undefined && input.scanRoot !== null
         ? path.resolve(input.scanRoot)
         : path.resolve(activationRoot, "event-exports");
+    const pollIntervalSeconds = Number.isInteger(input.pollIntervalSeconds) && (input.pollIntervalSeconds ?? 0) > 0
+        ? input.pollIntervalSeconds
+        : DEFAULT_WATCH_POLL_INTERVAL_SECONDS;
     const sessionTailCursorPath = resolveWatchSessionTailCursorPath(activationRoot);
     const teacherSnapshotPath = resolveWatchTeacherSnapshotPath(activationRoot);
     const restoredTeacherState = loadWatchTeacherSnapshotState(teacherSnapshotPath);
@@ -3586,14 +4833,25 @@ export async function createWatchCommandRuntime(input) {
     log(`Scan root: ${shortenPath(scanRoot)}`);
     log(`State: cursor=${shortenPath(sessionTailCursorPath)} snapshot=${shortenPath(teacherSnapshotPath)}`);
     const resolvedTeacherLabeler = resolveWatchTeacherLabelerConfig(input.teacherLabeler, activationRoot);
+    const resolvedEmbedder = resolveWatchEmbedderConfig(input.embedder, activationRoot);
     const teacherLabeler = resolvedTeacherLabeler.teacherLabeler;
     for (const warning of resolvedTeacherLabeler.warnings) {
         startupWarnings.push(`teacher_config_warning:${warning}`);
         log(`Teacher config warning: ${warning}`);
     }
+    for (const warning of resolvedEmbedder.warnings) {
+        startupWarnings.push(`embedder_config_warning:${warning}`);
+        log(`Embedder config warning: ${warning}`);
+    }
     if (teacherLabeler?.provider === "ollama") {
         log(`Teacher labeler: provider=ollama model=${teacherLabeler.model ?? "qwen3.5:9b"}`);
     }
+    if (resolvedEmbedder.embedder !== null) {
+        log(`Embedder: provider=ollama model=${resolvedEmbedder.embedder.model}`);
+    }
+    else {
+        log("Embedder: numeric pack materialization is not configured; watch will keep keyword/weight vectors only.");
+    }
     const scanner = createRuntimeEventExportScanner({ scanRoot });
     let lastServeTimeFallbackReason = null;
     const baseTeacherLoopInput = {
@@ -3630,10 +4888,23 @@ export async function createWatchCommandRuntime(input) {
     };
     let teacherLoop;
     let lastHandledMaterializationPackId = restoredTeacherState.lastHandledMaterializationPackId;
+    let lastEmbedInstrumentation = restoredTeacherState.embedInstrumentation;
+    let restoredLastObservedDelta = restoredTeacherState.lastObservedDelta;
     if (restoredTeacherState.error !== null) {
         const message = restoredTeacherState.error;
         startupWarnings.push(`teacher_snapshot_reset:${message}`);
         lastHandledMaterializationPackId = null;
+        lastEmbedInstrumentation = null;
+        restoredLastObservedDelta = {
+            available: true,
+            observedAt: bootstrapObservedAt,
+            exported: false,
+            labeled: false,
+            promoted: false,
+            served: false,
+            latestPackTransition: null,
+            explanation: "Watch reset an unreadable teacher snapshot, so no prior last-turn delta can be trusted."
+        };
         log(`Teacher snapshot reset: ${message}`);
         teacherLoop = createAsyncTeacherLiveLoop(baseTeacherLoopInput);
     }
@@ -3648,6 +4919,17 @@ export async function createWatchCommandRuntime(input) {
             const message = formatWatchError(error);
             startupWarnings.push(`teacher_snapshot_reset:${message}`);
             lastHandledMaterializationPackId = null;
+            lastEmbedInstrumentation = null;
+            restoredLastObservedDelta = {
+                available: true,
+                observedAt: bootstrapObservedAt,
+                exported: false,
+                labeled: false,
+                promoted: false,
+                served: false,
+                latestPackTransition: null,
+                explanation: "Watch reset an unusable teacher snapshot, so no prior last-turn delta can be trusted."
+            };
             log(`Teacher snapshot reset: ${message}`);
             teacherLoop = createAsyncTeacherLiveLoop(baseTeacherLoopInput);
         }
@@ -3656,11 +4938,28 @@ 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 resolvedWatchProfileScope = input.profileRoots === undefined
+        ? resolveWatchProfileRootsForActivationRoot(activationRoot)
+        : {
+            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 {
         localSessionTail = createOpenClawLocalSessionTail({
-            ...(input.profileRoots === undefined ? {} : { profileRoots: input.profileRoots }),
+            ...(resolvedProfileRoots === undefined ? {} : { profileRoots: resolvedProfileRoots }),
             cursor: restoredCursor,
             emitExistingOnFirstPoll: restoredCursor.length === 0
         });
@@ -3670,7 +4969,7 @@ export async function createWatchCommandRuntime(input) {
         log(`Session tail cursor reset: ${message}`);
         restoredCursor = [];
         localSessionTail = createOpenClawLocalSessionTail({
-            ...(input.profileRoots === undefined ? {} : { profileRoots: input.profileRoots }),
+            ...(resolvedProfileRoots === undefined ? {} : { profileRoots: resolvedProfileRoots }),
             emitExistingOnFirstPoll: true
         });
         persistWatchSessionTailCursor(sessionTailCursorPath, []);
@@ -3691,8 +4990,11 @@ export async function createWatchCommandRuntime(input) {
         log(`Replayed ${replayState.replayedBundleCount} stored export bundle${replayState.replayedBundleCount === 1 ? "" : "s"} (${replayState.replayedEventCount} event${replayState.replayedEventCount === 1 ? "" : "s"})`);
     }
     let bootstrapSnapshot = teacherLoop.snapshot();
-    const replayPromotion = applyWatchMaterialization(activationRoot, bootstrapSnapshot, lastHandledMaterializationPackId);
+    const replayPromotion = await applyWatchMaterialization(activationRoot, bootstrapSnapshot, lastHandledMaterializationPackId, resolvedEmbedder.embedder, log);
     lastHandledMaterializationPackId = replayPromotion.lastHandledMaterializationPackId;
+    if (replayPromotion.embedInstrumentation !== null) {
+        lastEmbedInstrumentation = replayPromotion.embedInstrumentation;
+    }
     if (replayPromotion.logLine !== null) {
         log(replayPromotion.logLine);
         bootstrapSnapshot = teacherLoop.snapshot();
@@ -3700,6 +5002,7 @@ export async function createWatchCommandRuntime(input) {
     const bootstrapCursor = localSessionTail.snapshot();
     persistWatchTeacherSnapshot(teacherSnapshotPath, {
         lastRunAt: bootstrapObservedAt,
+        pollIntervalSeconds,
         scanRoot,
         sessionTailCursorPath,
         sessionTailCursorUpdatedAt: bootstrapObservedAt,
@@ -3715,26 +5018,44 @@ export async function createWatchCommandRuntime(input) {
         lastTeacherError: null,
         localSessionTailNoopReason: null,
         lastHandledMaterializationPackId,
+        lastObservedDelta: restoredLastObservedDelta.available
+            ? restoredLastObservedDelta
+            : {
+                available: true,
+                observedAt: bootstrapObservedAt,
+                exported: false,
+                labeled: false,
+                promoted: false,
+                served: false,
+                latestPackTransition: null,
+                explanation: "Watch bootstrapped its state, but no new local user-message delta has been observed yet."
+            },
+        embedInstrumentation: lastEmbedInstrumentation,
         failure: replayPromotion.failure,
         snapshot: bootstrapSnapshot
     });
     return {
         activationRoot,
         scanRoot,
+        pollIntervalSeconds,
         sessionTailCursorPath,
         teacherSnapshotPath,
         startupWarnings,
         lastTeacherError: null,
         replayState,
         lastHandledMaterializationPackId,
+        lastEmbedInstrumentation,
         scanner,
         teacherLoop,
-        localSessionTail
+        localSessionTail,
+        embedder: resolvedEmbedder.embedder
     };
 }
 export async function runWatchCommandPass(runtime, options = {}) {
     const log = options.log ?? watchLog;
     const observedAt = options.observedAt ?? new Date().toISOString();
+    const snapshotBefore = runtime.teacherLoop.snapshot();
+    const beforeInspection = inspectActivationState(runtime.activationRoot, observedAt);
     const localPoll = runtime.localSessionTail.pollOnce({
         observedAt
     });
@@ -3768,9 +5089,12 @@ export async function runWatchCommandPass(runtime, options = {}) {
             const ingestResult = await runtime.teacherLoop.ingestRuntimeEventExportScannerScan(scanResult);
             runtime.lastTeacherError = null;
             snapshot = ingestResult.snapshot;
-            const promotion = applyWatchMaterialization(runtime.activationRoot, snapshot, runtime.lastHandledMaterializationPackId);
+            const promotion = await applyWatchMaterialization(runtime.activationRoot, snapshot, runtime.lastHandledMaterializationPackId, runtime.embedder, log);
             runtime.lastHandledMaterializationPackId = promotion.lastHandledMaterializationPackId;
             materializedPackId = promotion.materializedPackId;
+            if (promotion.embedInstrumentation !== null) {
+                runtime.lastEmbedInstrumentation = promotion.embedInstrumentation;
+            }
             failure = promotion.failure;
             if (promotion.logLine !== null) {
                 log(promotion.logLine);
@@ -3802,8 +5126,20 @@ export async function runWatchCommandPass(runtime, options = {}) {
             snapshot = runtime.teacherLoop.snapshot();
         }
     }
+    const afterInspection = inspectActivationState(runtime.activationRoot, observedAt);
+    const lastObservedDelta = buildWatchLastObservedDelta({
+        observedAt,
+        localPoll,
+        exported,
+        scanResult,
+        snapshotBefore,
+        snapshotAfter: snapshot,
+        beforeInspection,
+        afterInspection
+    });
     persistWatchTeacherSnapshot(runtime.teacherSnapshotPath, {
         lastRunAt: observedAt,
+        pollIntervalSeconds: runtime.pollIntervalSeconds,
         scanRoot: runtime.scanRoot,
         sessionTailCursorPath: runtime.sessionTailCursorPath,
         sessionTailCursorUpdatedAt: observedAt,
@@ -3819,6 +5155,8 @@ export async function runWatchCommandPass(runtime, options = {}) {
         lastTeacherError: runtime.lastTeacherError,
         localSessionTailNoopReason: localPoll.noopReason,
         lastHandledMaterializationPackId: runtime.lastHandledMaterializationPackId,
+        lastObservedDelta,
+        embedInstrumentation: runtime.lastEmbedInstrumentation,
         failure,
         snapshot
     });
@@ -3839,6 +5177,7 @@ export async function runWatchCommandPass(runtime, options = {}) {
             scannerProcessedBundles: persistedScannerCheckpoint.processedExportDigests.length,
             scannerLiveAfter: persistedScannerCheckpoint.live.after?.exportDigest ?? null,
             materialized: materializedPackId,
+            lastObservedDelta,
             diagnostics: snapshot.diagnostics ?? null,
             localSessionTailNoopReason: localPoll.noopReason
         }));
@@ -3856,6 +5195,7 @@ async function runWatchCommand(parsed) {
     const runtime = await createWatchCommandRuntime({
         activationRoot: parsed.activationRoot,
         scanRoot: parsed.scanRoot,
+        pollIntervalSeconds: parsed.interval,
         log: watchLog
     });
     watchLog(`Interval: ${parsed.interval}s`);
@@ -4139,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);
@@ -4147,7 +5491,10 @@ export function runOperatorCli(argv = process.argv.slice(2)) {
     }
     else {
         const report = buildOperatorSurfaceReport(operatorInput);
-        const providerConfig = readOpenClawBrainProviderConfig(process.env);
+        const providerConfig = readOpenClawBrainProviderConfigFromSources({
+            env: process.env,
+            activationRoot
+        });
         if (statusOrRollback.detailed) {
             console.log(formatCurrentProfileStatusSummary(status, report, targetInspection, {
                 openclawHome: statusOrRollback.openclawHome,