@openclawbrain/openclaw 0.2.3 → 0.3.1

package/dist/src/cli.js

@@ -1,19 +1,30 @@
 #!/usr/bin/env node
-import { execSync } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, readdirSync, readSync, openSync, closeSync, realpathSync, rmSync, statSync, writeFileSync, appendFileSync, symlinkSync } from "node:fs";
+import { execFileSync, execSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, readdirSync, readSync, openSync, closeSync, realpathSync, rmSync, statSync, writeFileSync, symlinkSync } from "node:fs";
 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 { exportBrain, importBrain } from "./import-export.js";
 import { buildNormalizedEventExport } from "@openclawbrain/contracts";
 import { buildTeacherSupervisionArtifactsFromNormalizedEventExport, createAlwaysOnLearningRuntimeState, describeAlwaysOnLearningRuntimeState, drainAlwaysOnLearningRuntime, loadOrInitBaseline, materializeAlwaysOnLearningCandidatePack, persistBaseline } from "@openclawbrain/learner";
-import { inspectActivationState, promoteCandidatePack, readLearningSpineLogEntries, stageCandidatePack } from "@openclawbrain/pack-format";
+import { inspectActivationState, loadPackFromActivation, promoteCandidatePack, readLearningSpineLogEntries, stageCandidatePack } from "@openclawbrain/pack-format";
 import { resolveActivationRoot } from "./resolve-activation-root.js";
-import { buildNormalizedEventExportFromScannedEvents, bootstrapRuntimeAttach, buildOperatorSurfaceReport, compileRuntimeContext, createAsyncTeacherLiveLoop, createOpenClawLocalSessionTail, createRuntimeEventExportScanner, describeCurrentProfileBrainStatus, formatBootstrapRuntimeAttachReport, formatOperatorRollbackReport, loadRuntimeEventExportBundle, rollbackRuntimeAttach, resolveAsyncTeacherLiveLoopSnapshotPath, scanLiveEventExport, scanRecordedSession, summarizeLearningPathFromMaterialization, summarizeNormalizedEventExportLabelFlow, writeScannedEventExportBundle } from "./index.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 { 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";
+const OPENCLAWBRAIN_INSTALL_SKIP_EMBEDDER_PROVISION_ENV = "OPENCLAWBRAIN_INSTALL_SKIP_EMBEDDER_PROVISION";
+const INSTALL_COMPATIBLE_LOCAL_TEACHER_MODEL_PREFIXES = [
+    "qwen3.5:9b",
+    "qwen3.5:8b",
+    "qwen3:8b",
+    "qwen2.5:7b"
+];
 function quoteShellArg(value) {
     return `'${value.replace(/'/g, `"'"'`)}'`;
 }
@@ -24,37 +35,32 @@ function normalizeOptionalCliString(value) {
     const trimmed = value.trim();
     return trimmed.length > 0 ? trimmed : null;
 }
+function readTruthyEnvFlag(name, env = process.env) {
+    const value = normalizeOptionalCliString(env[name]);
+    if (value === null) {
+        return false;
+    }
+    return ["1", "true", "yes", "on"].includes(value.toLowerCase());
+}
 function getCliHomeDir() {
     return process.env.HOME ?? process.env.USERPROFILE ?? "~";
 }
-function discoverSetupCandidateOpenClawHomes(homeDir = getCliHomeDir()) {
-    const resolvedHomeDir = path.resolve(homeDir);
-    let entries;
-    try {
-        entries = readdirSync(resolvedHomeDir, { withFileTypes: true });
-    }
-    catch {
-        return [];
-    }
-    return entries
-        .filter((entry) => entry.isDirectory() && entry.name.startsWith(".openclaw-"))
-        .map((entry) => path.join(resolvedHomeDir, entry.name))
-        .filter((candidate) => existsSync(path.join(candidate, "openclaw.json")))
-        .sort((left, right) => left.localeCompare(right));
+function discoverInstallCandidateOpenClawHomes(homeDir = getCliHomeDir()) {
+    return discoverOpenClawHomes(homeDir).map((inspection) => inspection.openclawHome);
 }
-function formatSetupOpenClawHomeSource(source) {
+function formatInstallOpenClawHomeSource(source) {
     switch (source) {
         case "explicit":
             return "--openclaw-home";
         case "env":
             return "OPENCLAW_HOME";
-        case "discovered_single_profile":
-            return "single discovered live profile";
+        case "discovered_single_home":
+            return "single discovered install target";
         default:
             return source;
     }
 }
-function resolveSetupOpenClawHome(explicitOpenclawHome) {
+function resolveInstallOpenClawHome(explicitOpenclawHome) {
     const normalizedExplicitHome = normalizeOptionalCliString(explicitOpenclawHome);
     if (normalizedExplicitHome !== null) {
         return {
@@ -69,30 +75,30 @@ function resolveSetupOpenClawHome(explicitOpenclawHome) {
             openclawHomeSource: "env"
         };
     }
-    const discoveredHomes = discoverSetupCandidateOpenClawHomes();
+    const discoveredHomes = discoverInstallCandidateOpenClawHomes();
     if (discoveredHomes.length === 1) {
         return {
             openclawHome: path.resolve(discoveredHomes[0]),
-            openclawHomeSource: "discovered_single_profile"
+            openclawHomeSource: "discovered_single_home"
         };
     }
     if (discoveredHomes.length > 1) {
         const installPrefix = detectConsumerSafeOperatorCliPrefix();
-        const targetChoices = discoveredHomes
-            .map((candidate) => {
-            const resolvedCandidate = path.resolve(candidate);
-            return `  - ${resolvedCandidate}\n    ${installPrefix} install --openclaw-home ${quoteShellArg(resolvedCandidate)}`;
+        const targetChoices = discoverOpenClawHomes()
+            .map((inspection) => {
+            const resolvedCandidate = path.resolve(inspection.openclawHome);
+            return `  - ${resolvedCandidate} (${describeOpenClawHomeInspection(inspection)})\n    ${installPrefix} install --openclaw-home ${quoteShellArg(resolvedCandidate)}`;
         })
             .join("\n");
         throw new Error([
-            "Refusing ambiguous live OpenClaw targets for install/setup.",
+            "Refusing ambiguous OpenClaw install targets.",
             targetChoices,
-            "Pass --openclaw-home <path> or set OPENCLAW_HOME to pin one profile."
+            "Pass --openclaw-home <path> or set OPENCLAW_HOME to pin one OpenClaw home."
         ].join("\n"));
     }
-    throw new Error("No OpenClaw profile home found. Pass --openclaw-home <path> or set OPENCLAW_HOME.");
+    throw new Error("No OpenClaw home found. Pass --openclaw-home <path> or set OPENCLAW_HOME.");
 }
-function resolveSetupActivationRoot(openclawHome, explicitActivationRoot) {
+function resolveInstallActivationRoot(openclawHome, explicitActivationRoot) {
     const normalizedExplicitActivationRoot = normalizeOptionalCliString(explicitActivationRoot);
     if (normalizedExplicitActivationRoot !== null) {
         return {
@@ -105,7 +111,7 @@ function resolveSetupActivationRoot(openclawHome, explicitActivationRoot) {
         source: "default_from_openclaw_home"
     };
 }
-function resolveSetupWorkspaceId(openclawHome, explicitWorkspaceId) {
+function resolveInstallWorkspaceId(openclawHome, explicitWorkspaceId) {
     const normalizedExplicitWorkspaceId = normalizeOptionalCliString(explicitWorkspaceId);
     if (normalizedExplicitWorkspaceId !== null) {
         return {
@@ -113,18 +119,24 @@ function resolveSetupWorkspaceId(openclawHome, explicitWorkspaceId) {
             source: "explicit"
         };
     }
-    try {
-        const openclawConfigPath = path.join(openclawHome, "openclaw.json");
-        const openclawConfig = JSON.parse(readFileSync(openclawConfigPath, "utf8"));
-        if (typeof openclawConfig.profile === "string" && openclawConfig.profile.trim().length > 0) {
-            return {
-                workspaceId: openclawConfig.profile.trim(),
-                source: "openclaw_json_profile"
-            };
-        }
+    const inspection = inspectOpenClawHome(openclawHome);
+    if (inspection.profileId !== null) {
+        return {
+            workspaceId: inspection.profileId,
+            source: inspection.profileSource === "directory_name"
+                ? "openclaw_home_dir"
+                : inspection.profileSource === "openclaw_json_profile"
+                    ? "openclaw_json_profile"
+                    : inspection.profileSource === "openclaw_json_single_profile_key"
+                        ? "openclaw_json_single_profile_key"
+                        : "fallback"
+        };
     }
-    catch {
-        // Fall back to the profile-home name when setup is pointed at an incomplete or not-yet-readable profile.
+    if (inspection.layout === "shared_home_profiles_in_config" || inspection.layout === "single_openclaw_home") {
+        return {
+            workspaceId: "current_profile",
+            source: "current_profile_boundary"
+        };
     }
     const dirName = path.basename(openclawHome);
     if (dirName === ".openclaw") {
@@ -145,18 +157,40 @@ function resolveSetupWorkspaceId(openclawHome, explicitWorkspaceId) {
         source: "fallback"
     };
 }
-function formatSetupActivationRootSource(source) {
+function resolveInstallEmbedderProvisionSkip(explicitSkip) {
+    if (explicitSkip) {
+        return {
+            skipEmbedderProvision: true,
+            skipEmbedderProvisionSource: "flag"
+        };
+    }
+    if (readTruthyEnvFlag(OPENCLAWBRAIN_INSTALL_SKIP_EMBEDDER_PROVISION_ENV)) {
+        return {
+            skipEmbedderProvision: true,
+            skipEmbedderProvisionSource: "env"
+        };
+    }
+    return {
+        skipEmbedderProvision: false,
+        skipEmbedderProvisionSource: null
+    };
+}
+function formatInstallActivationRootSource(source) {
     if (source === "explicit") {
         return "explicit --activation-root";
     }
     return "default beside --openclaw-home";
 }
-function formatSetupWorkspaceIdSource(source) {
+function formatInstallWorkspaceIdSource(source) {
     switch (source) {
         case "explicit":
             return "explicit --workspace-id";
         case "openclaw_json_profile":
             return "from openclaw.json profile";
+        case "openclaw_json_single_profile_key":
+            return "from the only openclaw.json profiles entry";
+        case "current_profile_boundary":
+            return "current_profile boundary for a shared OpenClaw home";
         case "openclaw_home_dir":
             return "from OpenClaw home dir";
         default:
@@ -262,7 +296,7 @@ function buildDoctorDeletedMessage(args) {
     const jsonCommand = buildStatusReplacementCommand(replacementInput, true);
     const lines = [
         "`doctor` is no longer a separate operator surface.",
-        'Use `openclawbrain status` as the human answer to "How\'s the brain?" and `status --json` for the canonical current-profile object.',
+        'Use `openclawbrain status --activation-root <path>` as the human answer to "How\'s the brain?" and `status --json` for the canonical current-profile object.',
         "Use `describeAttachStatus()` or the proof helpers only when you need deeper activation diagnostics."
     ];
     if (json && jsonCommand !== null) {
@@ -276,36 +310,42 @@ function buildDoctorDeletedMessage(args) {
     }
     return lines.join(" ");
 }
+function buildSetupDeletedMessage() {
+    return [
+        "`setup` has been removed.",
+        "Use `openclawbrain install` instead.",
+        "The install command still accepts the explicit targeting flags that setup used: `--openclaw-home`, `--activation-root`, `--workspace-id`, and `--shared`."
+    ].join(" ");
+}
 function operatorCliHelp() {
     return [
         "Usage:",
         "  openclawbrain install [--openclaw-home <path>] [options]",
-        "  openclawbrain setup [--openclaw-home <path>] [options]              # compatibility alias",
+        "  openclawbrain attach --openclaw-home <path> [options]",
+        "  openclawbrain <status|rollback> [--activation-root <path>|--openclaw-home <path>] [options]",
+        "  openclawbrain watch --activation-root <path> [--scan-root <path>] [--interval <seconds>]",
+        "  openclawbrain daemon <start|stop|status|logs> --activation-root <path> [--json]",
         "  openclawbrain detach --openclaw-home <path> [options]",
         "  openclawbrain uninstall --openclaw-home <path> [--keep-data|--purge-data] [options]",
-        "  openclawbrain attach --activation-root <path> [options]",
-        "  openclawbrain <status|rollback> --activation-root <path> [options]",
-        "  openclawbrain context \"message\" [--activation-root <path>]",
-        "  openclawbrain history [--activation-root <path>] [--limit N] [--json]",
+        "  openclawbrain context \"message\" [--activation-root <path>|--openclaw-home <path>]",
+        "  openclawbrain history [--activation-root <path>|--openclaw-home <path>] [--limit N] [--json]",
         "  openclawbrain scan --session <trace.json> --root <path> [options]",
         "  openclawbrain scan --live <event-export-path> --workspace <workspace.json> [options]",
-        "  openclawbrain learn [--activation-root <path>] [--json]",
-        "  openclawbrain watch [--activation-root <path>] [--scan-root <path>] [--interval <seconds>]",
-        "  openclawbrain daemon <start|stop|status|logs> [--activation-root <path>]",
-        "  openclawbrain-ops <status|rollback> --activation-root <path> [options]  # compatibility alias",
+        "  openclawbrain learn [--activation-root <path>|--openclaw-home <path>] [--json]",
+        "  openclawbrain-ops <status|rollback> [--activation-root <path>|--openclaw-home <path>] [options]  # compatibility alias",
         "  openclawbrain-ops scan --session <trace.json> --root <path> [options]    # compatibility alias",
         "",
         "Options:",
-        "  --openclaw-home <path>      OpenClaw profile home dir for install/setup/detach/uninstall (e.g. ~/.openclaw-Tern). Auto-selects for install/setup when OPENCLAW_HOME is set or exactly one live profile home exists.",
-        "  --shared                    Set brain-attachment-policy to shared instead of dedicated (install/setup only).",
-        "  --activation-root <path>    Activation root for attach/detach/uninstall; install/setup defaults to sibling .openclawbrain/activation next to the selected OpenClaw home.",
+        "  --openclaw-home <path>      OpenClaw home dir for install/attach/detach/uninstall (e.g. ~/.openclaw-Tern or ~/.openclaw). Also pins status/rollback/context/history/learn to that installed target when applicable.",
+        "  --shared                    Set brain-attachment-policy to shared instead of dedicated (install/attach only).",
+        `  --skip-embedder-provision  Skip the default Ollama ${DEFAULT_OLLAMA_EMBEDDING_MODEL} pull before install/attach bootstrap. Use only when intentionally deferring embedder setup. Also supports ${OPENCLAWBRAIN_INSTALL_SKIP_EMBEDDER_PROVISION_ENV}=1.`,
+        "  --activation-root <path>    Explicit activation root for attach/watch/daemon and other stateful commands; install/attach default to sibling .openclawbrain/activation next to the selected OpenClaw home.",
         "  --keep-data                 Preserve activation data on uninstall; detach always behaves this way.",
         "  --purge-data                Remove activation data on uninstall; requires the installed profile hook or --activation-root.",
         "  --restart <never|safe|external>  Restart guidance mode for detach/uninstall. 'safe' is conservative; 'never' leaves restart entirely to the operator.",
-        "  --pack-root <path>          Initial pack root directory (attach only; defaults to <activation-root>/packs/initial).",
-        "  --workspace-id <id>         Workspace identifier for attach/install/setup provenance; install/setup defaults to openclaw.json.profile or the profile name, attach defaults to 'workspace'.",
+        "  --workspace-id <id>         Workspace identifier for install/attach provenance; defaults to the detected profile target from openclaw.json when possible, otherwise the profile name or current_profile boundary.",
         "  --event-export <path>       Event-export bundle root or normalized export JSON payload.",
-        "  --teacher-snapshot <path>   Async teacher snapshot JSON from teacherLoop.snapshot()/flush(); keeps live-first, principal-priority, and passive-backfill learner truth explicit.",
+        "  --teacher-snapshot <path>   Canonical watch teacher snapshot JSON or raw async teacher snapshot JSON; keeps live-first, principal-priority, and passive-backfill learner truth explicit.",
         "  --updated-at <iso>          Observation time to use for freshness checks.",
         "  --brain-attachment-policy <undeclared|dedicated|shared>  Override attachment policy semantics for status inspection.",
         "  --detailed                   Show verbose diagnostic output for status (default is human-friendly summary).",
@@ -313,7 +353,7 @@ function operatorCliHelp() {
         "  --session <path>            Sanitized recorded-session trace JSON to replay.",
         "  --live <path>               Runtime event-export bundle root or normalized export JSON to scan once.",
         "  --root <path>               Output root for scan --session replay artifacts.",
-        "  --workspace <path>          Workspace metadata JSON for scan --live candidate provenance.",
+        "  --workspace <path>          Workspace metadata JSON for scan --live candidate materialization.",
         "  --pack-label <label>        Candidate-pack label for scan --live. Defaults to scanner-live-cli.",
         "  --observed-at <iso>         Observation time for scan --live freshness checks.",
         "  --snapshot-out <path>       Write the one-shot scan --live snapshot JSON.",
@@ -323,24 +363,31 @@ function operatorCliHelp() {
         "  --json                      Emit machine-readable JSON instead of text.",
         "  --help                      Show this help.",
         "",
-        "Common flow:",
-        "  0. install     openclawbrain install — attach the brain with sane defaults; pass --openclaw-home for explicit targeting on many-profile hosts",
-        "  0. detach      openclawbrain detach --openclaw-home <path> — remove the profile hook only; activation data stays in place",
-        "  0. uninstall   openclawbrain uninstall --openclaw-home <path> --keep-data|--purge-data — remove the profile hook and choose the data outcome explicitly",
-        "  0. context     openclawbrain context \"hello\" — preview the brain context that would be injected for a message",
-        "  0. attach      openclawbrain attach --activation-root <path>",
-        "  1. status          answer \"How's the brain?\" for the current profile on that activation root",
-        "  2. status --json   read the canonical current_profile_brain_status.v1 object for that same boundary",
-        "  3. rollback --dry-run   preview active <- previous, active -> candidate",
-        "  4. rollback             apply the rollback when the preview says ready",
-        "  5. scan --session   replay one sanitized session trace across no_brain, seed_pack, and learned_replay",
-        "  6. scan --live      scan one live event export into teacher/learner state without claiming a daemon is running",
+        "Lifecycle flow:",
+        "  1. install            openclawbrain install — safe first-time default; pass --openclaw-home when more than one OpenClaw home/layout is present",
+        "  2. attach             openclawbrain attach --openclaw-home <path> [--activation-root <path>] — explicit reattach/manual hook path for known brain data; use install first",
+        "  3. status             openclawbrain status --activation-root <path> — answer \"How's the brain?\" for that boundary",
+        "  4. status --detailed  openclawbrain status --activation-root <path> --detailed — explain serve path, freshness, backlog, and failure mode",
+        "  5. watch              openclawbrain watch --activation-root <path> — run the foreground learning/watch loop",
+        "  6. daemon start       openclawbrain daemon start --activation-root <path> — keep watch running in the background on macOS",
+        "  7. daemon status      openclawbrain daemon status --activation-root <path> — inspect the background watch state",
+        "  8. detach             openclawbrain detach --openclaw-home <path> — remove the profile hookup only and keep brain data",
+        "  9. uninstall          openclawbrain uninstall --openclaw-home <path> --keep-data|--purge-data — remove the hookup and choose the data outcome explicitly",
+        "",
+        "Advanced/operator surfaces:",
+        "  context      preview the brain context that would be injected for a message",
+        "  rollback     preview or apply active <- previous, active -> candidate pointer movement",
+        "  scan         inspect one recorded session or live event export without claiming a daemon is running",
+        "  learn        one-shot local-session learning pass against the resolved activation root",
         "  status --teacher-snapshot keeps the current live-first / principal-priority / passive-backfill learner order visible when that snapshot exists",
-        "  watch/daemon persist that snapshot at <activation-root>/async-teacher-live-loop.snapshot.json; --teacher-snapshot overrides the default path",
+        "  watch/daemon persist their operator snapshot at <activation-root>/watch/teacher-snapshot.json; --teacher-snapshot overrides the default path",
+        "  watch teacher defaults come from install-written provider-defaults.json under the activation root; OPENCLAWBRAIN_TEACHER_* and OPENCLAWBRAIN_EMBEDDER_* are host-shell overrides only, not live gateway wiring",
         "",
         "Exit codes:",
+        "  install: 0 on successful profile hookup/bootstrap, 1 on input/read failure.",
         "  status: 0 on successful inspection, 1 on input/read failure.",
         "  rollback: 0 when ready/applied, 1 when blocked or on input/read failure.",
+        "  attach: 0 on successful profile hookup/bootstrap, 1 on input/read failure.",
         "  detach: 0 on successful unhook, 1 on input/read failure.",
         "  uninstall: 0 on successful unhook/cleanup, 1 on input/read failure.",
         "  scan: 0 on successful replay/scan, 1 on input/read failure."
@@ -382,7 +429,8 @@ function formatLearningBuckets(report) {
     return `pi:${buckets.principal_immediate},pb:${buckets.principal_backfill},live:${buckets.live},backfill:${buckets.backfill}`;
 }
 function formatLearningWarnings(report) {
-    return report.learning.warningStates.length === 0 ? "none" : report.learning.warningStates.join("|");
+    const warnings = report.learning.warningStates.filter((warning) => warning !== "teacher_snapshot_unavailable");
+    return warnings.length === 0 ? "none" : warnings.join("|");
 }
 function formatLabelFlowSummary(labelFlow) {
     return `source=${labelFlow.source} human=${labelFlow.humanLabelCount ?? "none"} self=${labelFlow.selfLabelCount ?? "none"} implicitPositive=${labelFlow.implicitPositiveCount ?? "none"} teacherArtifacts=${labelFlow.asyncTeacherArtifactCount ?? "none"}`;
@@ -390,14 +438,322 @@ function formatLabelFlowSummary(labelFlow) {
 function formatLearningPathSummary(learningPath) {
     return `source=${learningPath.source} pg=${learningPath.policyGradientVersion} method=${learningPath.policyGradientMethod ?? "none"} target=${learningPath.targetConstruction ?? "none"} connect=${learningPath.connectOpsFired ?? "none"} trajectories=${learningPath.reconstructedTrajectoryCount ?? "none"}`;
 }
-function formatCurrentProfileStatusSummary(status, report) {
+function formatTeacherLoopSummary(report) {
+    const parts = [
+        `snapshot=${report.teacherLoop.sourcePath ?? "none"}`,
+        `kind=${report.teacherLoop.sourceKind}`,
+        `lastRun=${report.teacherLoop.lastRunAt ?? "none"}`,
+        `artifacts=${report.teacherLoop.artifactCount ?? "none"}`,
+        `freshness=${report.teacherLoop.latestFreshness}`,
+        `queue=${report.teacherLoop.queueDepth ?? "none"}/${report.teacherLoop.queueCapacity ?? "none"}`,
+        `running=${yesNo(report.teacherLoop.running)}`
+    ];
+    if (report.teacherLoop.lastNoOpReason !== "none") {
+        parts.push(`noOp=${report.teacherLoop.lastNoOpReason}`);
+    }
+    if (report.teacherLoop.failureMode !== "none") {
+        const failureDetail = report.teacherLoop.failureDetail === null
+            ? report.teacherLoop.failureMode
+            : `${report.teacherLoop.failureMode}(${report.teacherLoop.failureDetail})`;
+        parts.push(`failure=${failureDetail}`);
+    }
+    return parts.join(" ");
+}
+function formatCompactValue(value, maxLength = 64) {
+    return value.length <= maxLength ? value : `${value.slice(0, maxLength - 1)}...`;
+}
+function formatCompactList(values, maxItems = 2, maxLength = 64) {
+    if (values.length === 0) {
+        return "none";
+    }
+    const visible = values.slice(0, maxItems).map((value) => formatCompactValue(value, maxLength));
+    return values.length > maxItems ? `${visible.join("|")}+${values.length - maxItems}more` : visible.join("|");
+}
+const SERVICE_RISK_FINDING_CODES = new Set([
+    "activation_broken_install",
+    "activation_stale_incomplete",
+    "active_missing",
+    "active_unhealthy",
+    "learned_route_missing",
+    "serve_path_fail_open",
+    "serve_path_hard_fail",
+    "serve_path_route_evidence_missing"
+]);
+const DEGRADED_BRAIN_FINDING_CODES = new Set([
+    "bootstrap_waiting_for_first_export",
+    "serve_path_unprobed",
+    "brain_context_kernel_only",
+    "candidate_unhealthy",
+    "promotion_blocked",
+    "supervision_not_flowing",
+    "scan_surfaces_missing"
+]);
+const COSMETIC_FINDING_CODES = new Set([
+    "last_promotion_unknown",
+    "rollback_blocked",
+    "supervision_unavailable",
+    "turn_attribution_partial",
+    "teacher_snapshot_unavailable"
+]);
+const LEARNING_WARNING_MESSAGES = {
+    awaiting_first_export: "awaiting first export",
+    principal_live_backlog: "principal live backlog is ahead of serving",
+    principal_backfill_pending: "principal backfill is still queued",
+    active_pack_behind_latest_principal: "active pack is behind the latest principal correction",
+    passive_backfill_pending: "passive backfill remains queued",
+    teacher_queue_full: "teacher queue is full",
+    teacher_labels_stale: "teacher labels are stale",
+    teacher_no_artifacts: "teacher produced no artifacts",
+    teacher_snapshot_unavailable: "teacher snapshot is unavailable"
+};
+function summarizeStatusInstallHook(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"
+        };
+    }
+    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)) {
+        return {
+            state: "installed",
+            detail: `profile hook is installed at ${shortenPath(extensionDir)}`
+        };
+    }
+    return {
+        state: "not_installed",
+        detail: `profile hook is not present at ${shortenPath(extensionDir)}`
+    };
+}
+function runOllamaProbe(args, baseUrl) {
+    try {
+        execFileSync("ollama", [...args], {
+            stdio: "pipe",
+            timeout: 2_000,
+            env: {
+                ...process.env,
+                OLLAMA_HOST: baseUrl
+            }
+        });
+        return {
+            detected: true,
+            detail: `ollama responded to ${args.join(" ")} at ${baseUrl}`
+        };
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+            return {
+                detected: false,
+                detail: "ollama CLI was not found on PATH"
+            };
+        }
+        return {
+            detected: true,
+            detail: describeExecFailure(error)
+        };
+    }
+}
+function summarizeStatusEmbeddings(report, providerConfig) {
+    let embeddedEntryCount = null;
+    let totalEntryCount = null;
+    let models = [];
+    let liveState = "unknown";
+    let liveDetail = "no activation-ready active pack is available for embedding inspection";
+    if (report.active !== null && report.active.activationReady) {
+        try {
+            const activePack = loadPackFromActivation(report.activationRoot, "active", {
+                requireActivationReady: true
+            });
+            if (activePack !== null) {
+                totalEntryCount = activePack.vectors.entries.length;
+                embeddedEntryCount = activePack.vectors.entries.filter((entry) => entry.embedding !== undefined).length;
+                models = [...new Set(activePack.vectors.entries.flatMap((entry) => (entry.embedding === undefined ? [] : [entry.embedding.model])))].sort((left, right) => left.localeCompare(right));
+                liveState = embeddedEntryCount > 0 ? "yes" : "no";
+                liveDetail = `active pack stores ${embeddedEntryCount}/${totalEntryCount} numeric embeddings`;
+            }
+        }
+        catch (error) {
+            liveDetail = `embedding inspection failed: ${toErrorMessage(error)}`;
+        }
+    }
+    if (providerConfig.embedder.provider === "off") {
+        return {
+            provider: providerConfig.embedder.provider,
+            model: providerConfig.embedder.model,
+            provisionedState: "off",
+            liveState,
+            embeddedEntryCount,
+            totalEntryCount,
+            models,
+            detail: `${liveDetail}; embedder provider is off`
+        };
+    }
+    if (providerConfig.embedder.provider === "keywords") {
+        return {
+            provider: providerConfig.embedder.provider,
+            model: providerConfig.embedder.model,
+            provisionedState: "builtin",
+            liveState,
+            embeddedEntryCount,
+            totalEntryCount,
+            models,
+            detail: `${liveDetail}; keyword embedder needs no Ollama model provision`
+        };
+    }
+    const modelProbe = runOllamaProbe(["show", providerConfig.embedder.model], providerConfig.embedderBaseUrl);
+    return {
+        provider: providerConfig.embedder.provider,
+        model: providerConfig.embedder.model,
+        provisionedState: modelProbe.detected && /responded to/.test(modelProbe.detail) ? "confirmed" : "not_confirmed",
+        liveState,
+        embeddedEntryCount,
+        totalEntryCount,
+        models,
+        detail: `${liveDetail}; ollama model check: ${modelProbe.detail}`
+    };
+}
+function summarizeStatusLocalLlm(providerConfig) {
+    const detection = runOllamaProbe(["--version"], providerConfig.teacherBaseUrl);
+    const enabled = providerConfig.teacher.provider === "ollama";
+    if (enabled) {
+        return {
+            detected: detection.detected,
+            enabled,
+            provider: providerConfig.teacher.provider,
+            model: providerConfig.teacher.model,
+            detail: detection.detected
+                ? `teacher provider is ollama and the local LLM surface answered at ${providerConfig.teacherBaseUrl}`
+                : `teacher provider is ollama but the local LLM surface was not detected (${detection.detail})`
+        };
+    }
+    return {
+        detected: detection.detected,
+        enabled,
+        provider: providerConfig.teacher.provider,
+        model: providerConfig.teacher.model,
+        detail: detection.detected
+            ? `local Ollama is detectable, but teacher labeling is ${providerConfig.teacher.provider}`
+            : `teacher labeling is ${providerConfig.teacher.provider}; no local Ollama CLI was detected`
+    };
+}
+function pushUniqueAlert(target, value) {
+    const normalized = value.trim();
+    if (normalized.length === 0) {
+        return;
+    }
+    if (target.includes(normalized) === false) {
+        target.push(normalized);
+    }
+}
+function summarizeStatusAlerts(report, providerConfig, embeddings, localLlm) {
+    const buckets = {
+        serviceRisk: [],
+        degradedBrain: [],
+        cosmeticNoise: []
+    };
+    for (const finding of report.findings) {
+        if (finding.severity === "pass") {
+            continue;
+        }
+        if (SERVICE_RISK_FINDING_CODES.has(finding.code)) {
+            pushUniqueAlert(buckets.serviceRisk, finding.summary);
+            continue;
+        }
+        if (DEGRADED_BRAIN_FINDING_CODES.has(finding.code)) {
+            pushUniqueAlert(buckets.degradedBrain, finding.summary);
+            continue;
+        }
+        if (COSMETIC_FINDING_CODES.has(finding.code)) {
+            pushUniqueAlert(buckets.cosmeticNoise, finding.summary);
+            continue;
+        }
+        pushUniqueAlert(finding.severity === "fail" ? buckets.serviceRisk : buckets.degradedBrain, finding.summary);
+    }
+    for (const warningState of report.learning.warningStates) {
+        const message = LEARNING_WARNING_MESSAGES[warningState];
+        if (message === undefined) {
+            continue;
+        }
+        if (warningState === "teacher_snapshot_unavailable") {
+            pushUniqueAlert(buckets.cosmeticNoise, message);
+        }
+        else {
+            pushUniqueAlert(buckets.degradedBrain, message);
+        }
+    }
+    if (providerConfig.warnings.length > 0) {
+        pushUniqueAlert(buckets.cosmeticNoise, "provider env warnings forced fallback defaults");
+    }
+    if (localLlm.enabled && !localLlm.detected) {
+        pushUniqueAlert(buckets.degradedBrain, "local LLM is enabled but not detected");
+    }
+    if (embeddings.provider === "ollama" && embeddings.provisionedState !== "confirmed") {
+        pushUniqueAlert(buckets.degradedBrain, `embedder model ${embeddings.model} is not confirmed on Ollama`);
+    }
+    if (embeddings.provider === "ollama" && embeddings.liveState === "no") {
+        pushUniqueAlert(buckets.degradedBrain, "embedder is provisioned but the active pack has no live numeric embeddings");
+    }
+    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 summarizeStatusServeReality(status) {
+    if (status.brainStatus.serveState === "serving_active_pack") {
+        return "proven_active_pack";
+    }
+    return status.brainStatus.serveState;
+}
+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";
+    }
+    return status.brainStatus.serveState === "serving_active_pack" ? "BRAIN_LOADED" : "BRAIN_NOT_YET_LOADED";
+}
+function buildCompactStatusHeader(status, report, options) {
+    const installHook = summarizeStatusInstallHook(options.openclawHome);
+    const embeddings = summarizeStatusEmbeddings(report, options.providerConfig);
+    const localLlm = summarizeStatusLocalLlm(options.providerConfig);
+    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("|");
+    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`,
+        `explain     ${status.brain.summary}`,
+        `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 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}`,
+        ...buildCompactStatusHeader(status, report, options),
         `answer      ${status.brain.summary}`,
+        targetLine,
+        ...(targetInspection === null ? [] : [`preflight   ${formatOpenClawTargetExplanation(targetInspection)}`]),
         `host        runtime=${status.host.runtimeOwner} activation=${status.host.activationRoot}`,
         `profile     selector=${status.profile.selector}${profileIdSuffix} attachment=${status.attachment.state} policy=${status.attachment.policyMode}`,
         `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"}`,
         `serve       state=${status.brainStatus.serveState} failOpen=${yesNo(status.brainStatus.failOpen)} hardFail=${yesNo(report.servePath.hardRequirementViolated)} usedRouteFn=${yesNo(status.brainStatus.usedLearnedRouteFn)} awaitingFirstExport=${yesNo(status.brainStatus.awaitingFirstExport)} detail=${status.brainStatus.detail}`,
         `route       router=${report.servePath.routerIdentity ?? status.brain.routerIdentity ?? "none"} supervision=${report.servePath.refreshStatus ?? status.brain.routeFreshness} freshness=${report.servePath.freshnessChecksum ?? "none"}`,
@@ -409,7 +765,8 @@ function formatCurrentProfileStatusSummary(status, report) {
         `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}`,
         `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     snapshot=${report.teacherLoop.sourcePath ?? "none"} started=${report.teacherLoop.startedAt ?? "none"} heartbeat=${report.teacherLoop.lastHeartbeatAt ?? "none"} scan=${report.teacherLoop.lastScanAt ?? report.teacherLoop.lastProcessedAt ?? "none"} queue=${report.teacherLoop.queueDepth ?? "none"}/${report.teacherLoop.queueCapacity ?? "none"} running=${yesNo(report.teacherLoop.running)} lastJob=${report.teacherLoop.lastAppliedMaterializationJobId ?? "none"} lastPack=${report.teacherLoop.lastMaterializedPackId ?? "none"}`,
+        `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"}`,
         `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"}`,
@@ -426,15 +783,322 @@ function shortenPath(fullPath) {
     }
     return fullPath;
 }
+function formatOpenClawTargetLine(inspection) {
+    const profilePart = inspection.profileId === null
+        ? "profile=current_profile"
+        : `profile=${inspection.profileId} via ${formatOpenClawHomeProfileSource(inspection.profileSource)}`;
+    return `home=${shortenPath(inspection.openclawHome)} layout=${formatOpenClawHomeLayout(inspection.layout)} ${profilePart}`;
+}
+function formatOpenClawTargetExplanation(inspection) {
+    return describeOpenClawHomeInspection(inspection);
+}
 function buildInstallStatusCommand(activationRoot) {
     return `openclawbrain status --activation-root ${quoteShellArg(activationRoot)}`;
 }
 function buildInstallCommand(openclawHome) {
     return `openclawbrain install --openclaw-home ${quoteShellArg(openclawHome)}`;
 }
+function buildAttachCommand(openclawHome, activationRoot = null) {
+    const parts = ["openclawbrain", "attach", "--openclaw-home", quoteShellArg(openclawHome)];
+    if (activationRoot !== null) {
+        parts.push("--activation-root", quoteShellArg(activationRoot));
+    }
+    return parts.join(" ");
+}
+function buildInstallEmbedderProvisionCommand(baseUrl, model) {
+    return `OLLAMA_HOST=${quoteShellArg(baseUrl)} ollama pull ${quoteShellArg(model)}`;
+}
+function describeExecOutput(value) {
+    if (typeof value === "string") {
+        const normalized = value.trim();
+        return normalized.length > 0 ? normalized : null;
+    }
+    if (value instanceof Buffer) {
+        const normalized = value.toString("utf8").trim();
+        return normalized.length > 0 ? normalized : null;
+    }
+    return null;
+}
+function describeExecFailure(error) {
+    if (error instanceof Error) {
+        const childError = error;
+        if (childError.code === "ENOENT") {
+            return "ollama was not found on PATH";
+        }
+        const stderr = describeExecOutput(childError.stderr);
+        if (stderr !== null) {
+            return stderr;
+        }
+        const stdout = describeExecOutput(childError.stdout);
+        if (stdout !== null) {
+            return stdout;
+        }
+        const message = childError.message.trim();
+        if (message.length > 0) {
+            return message;
+        }
+    }
+    return String(error);
+}
+function toErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function ensureInstallEmbedderReady(parsed) {
+    const providerConfig = readOpenClawBrainProviderConfig(process.env);
+    const model = DEFAULT_OLLAMA_EMBEDDING_MODEL;
+    const baseUrl = providerConfig.embedderBaseUrl;
+    if (parsed.skipEmbedderProvision) {
+        const skipReason = parsed.skipEmbedderProvisionSource === "flag"
+            ? "--skip-embedder-provision"
+            : `${OPENCLAWBRAIN_INSTALL_SKIP_EMBEDDER_PROVISION_ENV}=1`;
+        return {
+            state: "skipped",
+            model,
+            baseUrl,
+            detail: `Skipped default embedder provisioning (${skipReason}); ${parsed.command} continued only because the operator explicitly opted out. ` +
+                `Provision it later with ${buildInstallEmbedderProvisionCommand(baseUrl, model)}.`
+        };
+    }
+    try {
+        execFileSync("ollama", ["pull", model], {
+            stdio: "pipe",
+            env: {
+                ...process.env,
+                OLLAMA_HOST: baseUrl
+            }
+        });
+    }
+    catch (error) {
+        const detail = describeExecFailure(error);
+        throw new Error(`Default embedder provisioning failed before brain init. Tried ${buildInstallEmbedderProvisionCommand(baseUrl, model)}. ` +
+            `${parsed.command === "install" ? "Install" : "Attach"} stops here so the bootstrap path does not quietly continue without ${model}. ` +
+            `Fix Ollama and rerun ${parsed.command}, or explicitly skip with --skip-embedder-provision or ${OPENCLAWBRAIN_INSTALL_SKIP_EMBEDDER_PROVISION_ENV}=1. ` +
+            `Detail: ${detail}`);
+    }
+    return {
+        state: "ensured",
+        model,
+        baseUrl,
+        detail: `Ensured default embedder before brain bootstrap: ${buildInstallEmbedderProvisionCommand(baseUrl, model)}`
+    };
+}
+function parseOllamaListModelNames(output) {
+    return output
+        .split(/\r?\n/u)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0 && !/^name\s+/iu.test(line))
+        .map((line) => line.split(/\s+/u)[0] ?? "")
+        .filter((name) => name.length > 0);
+}
+function selectCompatibleLocalTeacherModel(models) {
+    const normalized = models.map((model) => model.trim()).filter((model) => model.length > 0);
+    for (const prefix of INSTALL_COMPATIBLE_LOCAL_TEACHER_MODEL_PREFIXES) {
+        const exact = normalized.find((model) => model === prefix);
+        if (exact !== undefined) {
+            return exact;
+        }
+        const variant = normalized.find((model) => model.startsWith(`${prefix}-`) ||
+            model.startsWith(`${prefix}_`) ||
+            model.startsWith(`${prefix}.`));
+        if (variant !== undefined) {
+            return variant;
+        }
+    }
+    return null;
+}
+function detectInstallTeacherDefaults(baseUrl) {
+    try {
+        const output = execFileSync("ollama", ["list"], {
+            stdio: "pipe",
+            env: {
+                ...process.env,
+                OLLAMA_HOST: baseUrl
+            }
+        }).toString("utf8");
+        const availableModels = parseOllamaListModelNames(output);
+        const model = selectCompatibleLocalTeacherModel(availableModels);
+        if (model === null) {
+            return {
+                provider: "heuristic",
+                model: null,
+                baseUrl,
+                availableModels,
+                detectionDetail: availableModels.length === 0
+                    ? `No compatible local Ollama teacher model detected on ${baseUrl}; watch keeps heuristic teacher defaults.`
+                    : `No compatible local Ollama teacher model detected on ${baseUrl}; saw ${availableModels.join(", ")} and kept heuristic teacher defaults.`
+            };
+        }
+        return {
+            provider: "ollama",
+            model,
+            baseUrl,
+            availableModels,
+            detectionDetail: `Detected compatible local Ollama teacher model ${model} on ${baseUrl}; watch will enable it by default from the installed activation root.`
+        };
+    }
+    catch (error) {
+        const detail = describeExecFailure(error);
+        return {
+            provider: "heuristic",
+            model: null,
+            baseUrl,
+            availableModels: [],
+            detectionDetail: `Local Ollama teacher autodetect failed on ${baseUrl}; kept heuristic teacher defaults. Detail: ${detail}`
+        };
+    }
+}
+function writeInstallProviderDefaults(parsed) {
+    const providerConfig = readOpenClawBrainProviderConfig(process.env);
+    const teacherDetection = detectInstallTeacherDefaults(providerConfig.teacherBaseUrl);
+    const defaultsPath = resolveOpenClawBrainProviderDefaultsPath(parsed.activationRoot);
+    const defaults = {
+        contract: "openclawbrain_provider_defaults.v1",
+        writtenAt: new Date().toISOString(),
+        source: "install",
+        teacherBaseUrl: providerConfig.teacherBaseUrl,
+        embedderBaseUrl: providerConfig.embedderBaseUrl,
+        teacher: {
+            provider: teacherDetection.provider,
+            model: teacherDetection.model,
+            detectedLocally: teacherDetection.provider === "ollama",
+            detectedFromModel: teacherDetection.model
+        },
+        embedder: {
+            provider: "ollama",
+            model: DEFAULT_OLLAMA_EMBEDDING_MODEL
+        }
+    };
+    writeFileSync(defaultsPath, JSON.stringify(defaults, null, 2) + "\n", "utf8");
+    return {
+        path: defaultsPath,
+        defaults,
+        detail: `Wrote local provider defaults: ${teacherDetection.detectionDetail}`,
+        lifecycleSummary: teacherDetection.provider === "ollama" && teacherDetection.model !== null
+            ? `Teacher: auto-enabled local Ollama model ${teacherDetection.model} from install-written defaults`
+            : "Teacher: no compatible local Ollama model detected; watch stays heuristic unless explicitly overridden"
+    };
+}
+function buildInstallBrainFeedbackSummary(input) {
+    const providerDefaultsPath = resolveOpenClawBrainProviderDefaultsPath(input.parsed.activationRoot);
+    const embedderState = input.embedderProvision === null ? "unchanged" : input.embedderProvision.state;
+    const teacherDefaults = input.providerDefaults?.defaults.teacher;
+    const teacherProvider = teacherDefaults?.provider ?? "unknown";
+    const teacherModel = teacherDefaults?.model ?? null;
+    const detectedLocalLlm = teacherDefaults?.detectedLocally ?? null;
+    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`;
+    return {
+        hookPath: input.extensionDir,
+        providerDefaultsPath,
+        embedder: {
+            provider: "ollama",
+            model: DEFAULT_OLLAMA_EMBEDDING_MODEL,
+            state: embedderState
+        },
+        teacher: {
+            provider: teacherProvider,
+            model: teacherModel,
+            detectedLocalLlm
+        },
+        startup: {
+            token: "BRAIN_NOT_YET_LOADED",
+            proof: "restart_required"
+        },
+        provedNow,
+        notYetProved,
+        lines: [
+            `target      ${formatOpenClawTargetLine(input.targetInspection)} source=${formatInstallOpenClawHomeSource(input.parsed.openclawHomeSource)}`,
+            `hook        written=${shortenPath(input.extensionDir)}`,
+            `activation  root=${shortenPath(input.parsed.activationRoot)} source=${formatInstallActivationRootSource(input.parsed.activationRootSource)}`,
+            `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)}`,
+            "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.";
 }
+const LEGACY_PROFILE_NOTE_FILENAMES = ["BRAIN.md", "brain.md"];
+const LEGACY_BRAIN_AGENTS_LINE = "5. Read `BRAIN.md` — your learning brain context";
+function isLegacyBrainAdvisoryContent(content) {
+    return content.includes("## OpenClawBrain")
+        && content.includes("You have a learning brain attached at ")
+        && content.includes("openclawbrain status --activation-root")
+        && content.includes("openclawbrain rollback --activation-root");
+}
+function writeUpdatedTextFile(filePath, nextText, previousText) {
+    const normalizedNextText = previousText.endsWith("\n") ? `${nextText}\n` : nextText;
+    writeFileSync(filePath, normalizedNextText, "utf8");
+}
+function collectProfileResidueDirs(openclawHome) {
+    const directories = [path.resolve(openclawHome)];
+    try {
+        const entries = readdirSync(openclawHome, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory() && entry.name.startsWith("workspace-")) {
+                directories.push(path.join(openclawHome, entry.name));
+            }
+        }
+    }
+    catch {
+        // Residue cleanup stays best-effort.
+    }
+    return directories;
+}
+function removeLegacyProfileResidue(openclawHome) {
+    const removedNotes = [];
+    const updatedAgents = [];
+    for (const directory of collectProfileResidueDirs(openclawHome)) {
+        for (const fileName of LEGACY_PROFILE_NOTE_FILENAMES) {
+            const notePath = path.join(directory, fileName);
+            if (!existsSync(notePath)) {
+                continue;
+            }
+            try {
+                const content = readFileSync(notePath, "utf8");
+                if (!isLegacyBrainAdvisoryContent(content)) {
+                    continue;
+                }
+            }
+            catch {
+                continue;
+            }
+            rmSync(notePath, { force: true });
+            removedNotes.push(notePath);
+        }
+        const agentsPath = path.join(directory, "AGENTS.md");
+        if (!existsSync(agentsPath)) {
+            continue;
+        }
+        let agentsContent;
+        try {
+            agentsContent = readFileSync(agentsPath, "utf8");
+        }
+        catch {
+            continue;
+        }
+        const nextContent = agentsContent
+            .split("\n")
+            .filter((line) => line.trim() !== LEGACY_BRAIN_AGENTS_LINE)
+            .join("\n");
+        if (nextContent !== agentsContent) {
+            writeUpdatedTextFile(agentsPath, nextContent, agentsContent);
+            updatedAgents.push(agentsPath);
+        }
+    }
+    return {
+        removedNotes,
+        updatedAgents
+    };
+}
 function buildCleanupRestartGuidance(restart) {
     if (restart === "never") {
         return "No restart requested. If this OpenClaw profile is currently running, it may keep the previous hook state until the next restart.";
@@ -445,64 +1109,56 @@ 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) {
+    const activationRootArg = quoteShellArg(status.host.activationRoot);
+    if (status.brainStatus.activationState === "broken_install") {
+        return "Repair or replace the activation root before trusting serve-path status again.";
+    }
+    if (status.brainStatus.activationState === "stale_incomplete") {
+        return "Clean up or repair the retained activation state before reattaching or promoting packs.";
+    }
     if (status.brainStatus.status === "fail") {
-        return "Run `openclawbrain status --detailed` before changing lifecycle state so the serve-path failure is explicit.";
+        return `Run \`openclawbrain status --activation-root ${activationRootArg} --detailed\` before changing lifecycle state so the serve-path failure is explicit.`;
     }
     if (status.brainStatus.awaitingFirstExport) {
-        return "Let the attached OpenClaw profile emit a real export, then rerun `openclawbrain status`.";
+        return `Let the attached OpenClaw profile emit a real export, then rerun \`openclawbrain status --activation-root ${activationRootArg}\`.`;
     }
     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.";
     }
     if (report.rollback.allowed) {
-        return "Use `openclawbrain rollback --dry-run` before restoring the previous pack.";
-    }
-    return "Use `openclawbrain status --detailed` when you need the full lifecycle, serve-path, and backlog proof.";
-}
-function formatHumanFriendlyStatus(status, report) {
-    // Brain status line
-    const brainActive = status.brainStatus.status === "ok" || status.brainStatus.serveState === "serving_active_pack";
-    const brainIcon = brainActive ? "Active ✓" : status.brainStatus.status === "fail" ? "Inactive ✗" : `${status.brainStatus.status}`;
-    // Pack line
-    const packId = status.brain.activePackId ?? "none";
-    const packShort = packId.length > 9 ? packId.slice(0, 9) : packId;
-    const state = status.brain.state ?? "unknown";
-    // Activation root
-    const activationPath = shortenPath(status.host.activationRoot);
-    // Policy
-    const policy = status.attachment.policyMode ?? report.manyProfile.declaredAttachmentPolicy ?? "undeclared";
-    const principalFrontier = formatPrincipalCheckpointFrontier(report);
-    const pendingLive = String(report.learning.pendingLive ?? "none");
-    const pendingBackfill = String(report.learning.pendingBackfill ?? "none");
-    const nextLane = report.learning.nextPriorityLane ?? "none";
-    const nextBucket = report.learning.nextPriorityBucket ?? "none";
+        return `Use \`openclawbrain rollback --activation-root ${activationRootArg} --dry-run\` before restoring the previous pack.`;
+    }
+    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 lines = [
-        `Brain: ${brainIcon}`,
-        `Pack:  ${packShort} (${state})`,
-        `Activation: ${activationPath}`,
-        `Policy: ${policy}`,
-        `Lifecycle: attachment=${status.attachment.state} serve=${status.brainStatus.serveState} awaitingFirstExport=${yesNo(status.brainStatus.awaitingFirstExport)}`,
-        `Rollback: state=${report.rollback.state} ready=${yesNo(report.rollback.allowed)} previous=${report.rollback.previousPackId ?? "none"}`,
-        `Backlog: principal=${principalFrontier} live=${pendingLive} backfill=${pendingBackfill} next=${nextLane}/${nextBucket}`,
-        `Labels: ${formatLabelFlowSummary(report.labelFlow)}`,
-        `Learning: ${formatLearningPathSummary(report.learningPath)}`
+        `STATUS ${status.brainStatus.status}`,
+        ...buildCompactStatusHeader(status, report, options),
+        ...(targetInspection === null ? [] : [
+            `target      ${formatOpenClawTargetLine(targetInspection)}`,
+            `preflight   ${formatOpenClawTargetExplanation(targetInspection)}`
+        ]),
+        `next        ${buildStatusNextStep(status, report)}`
     ];
-    // Add learning/serve warnings if relevant
-    if (report.learning.warningStates.length > 0) {
-        lines.push(`Warnings: ${report.learning.warningStates.join(", ")}`);
+    return lines.join("\n");
+}
+function requireActivationRoot(input, openclawHome, command) {
+    const explicitActivationRoot = input.activationRoot.trim().length > 0 ? input.activationRoot : null;
+    if (explicitActivationRoot !== null) {
+        return path.resolve(explicitActivationRoot);
     }
-    if (status.brainStatus.awaitingFirstExport) {
-        lines.push(`Note: Awaiting first event export`);
+    if (openclawHome !== null) {
+        return resolveActivationRoot({
+            openclawHome
+        });
     }
-    lines.push(`Next: ${buildStatusNextStep(status, report)}`);
-    return lines.join("\n");
+    throw new Error(`${command} requires --activation-root <path> or --openclaw-home <path>; unpinned host auto-resolution is no longer supported for ${command}.`);
 }
-function requireActivationRoot(input, _command) {
-    // Use the shared auto-detect chain for ALL commands:
-    //   explicit flag → ~/.openclawbrain/activation → extension scan → clear error
+function resolveCliActivationRoot(explicitActivationRoot, openclawHome) {
     return resolveActivationRoot({
-        explicit: input.activationRoot.trim().length > 0 ? input.activationRoot : null,
+        explicit: explicitActivationRoot,
+        openclawHome
     });
 }
 function readJsonFile(filePath) {
@@ -530,10 +1186,18 @@ function formatScanSessionSummary(result) {
 function formatScanLiveSummary(result, snapshotOutPath) {
     const materializedPackId = result.snapshot.learner.lastMaterialization?.candidate.summary.packId ?? "none";
     const materializationReason = result.snapshot.learner.lastMaterialization?.reason ?? "none";
+    const teacherSummary = [
+        `artifacts=${result.snapshot.teacher.artifactCount}`,
+        `freshness=${result.snapshot.teacher.latestFreshness}`,
+        `humanLabels=${result.supervision.humanLabelCount}`
+    ];
+    if (result.snapshot.diagnostics.lastNoOpReason !== "none") {
+        teacherSummary.push(`noop=${result.snapshot.diagnostics.lastNoOpReason}`);
+    }
     return [
         "SCAN live ok",
         `source      digest=${result.supervision.exportDigest} session=${result.supervision.sessionId ?? "none"} channel=${result.supervision.channel ?? "none"} range=${result.supervision.eventRange.start}-${result.supervision.eventRange.end}/${result.supervision.eventRange.count}`,
-        `teacher     artifacts=${result.snapshot.teacher.artifactCount} freshness=${result.snapshot.teacher.latestFreshness} humanLabels=${result.supervision.humanLabelCount} noop=${result.snapshot.diagnostics.lastNoOpReason}`,
+        `teacher     ${teacherSummary.join(" ")}`,
         `labels      source=${result.labelFlow.source} human=${result.labelFlow.humanLabelCount ?? "none"} self=${result.labelFlow.selfLabelCount ?? "none"} implicitPositive=${result.labelFlow.implicitPositiveCount ?? "none"} teacherArtifacts=${result.labelFlow.asyncTeacherArtifactCount ?? "none"}`,
         `path        source=${result.learningPath.source} pg=${result.learningPath.policyGradientVersion} method=${result.learningPath.policyGradientMethod ?? "none"} target=${result.learningPath.targetConstruction ?? "none"} connect=${result.learningPath.connectOpsFired ?? "none"} trajectories=${result.learningPath.reconstructedTrajectoryCount ?? "none"}`,
         `learner     packLabel=${result.packLabel} materialized=${materializedPackId} reason=${materializationReason}`,
@@ -553,12 +1217,12 @@ export function parseOperatorCliArgs(argv) {
     let rootDir = null;
     let workspacePath = null;
     let packLabel = null;
-    let packRoot = null;
     let workspaceId = null;
     let observedAt = null;
     let snapshotOutPath = null;
     let openclawHome = null;
     let shared = false;
+    let skipEmbedderProvision = false;
     let keepData = false;
     let purgeData = false;
     let restart = "safe";
@@ -571,11 +1235,14 @@ export function parseOperatorCliArgs(argv) {
     if (args[0] === "doctor") {
         throw new Error(buildDoctorDeletedMessage(args.slice(1)));
     }
+    if (args[0] === "setup") {
+        throw new Error(buildSetupDeletedMessage());
+    }
     if (args[0] === "daemon") {
         args.shift();
         return parseDaemonArgs(args);
     }
-    if (args[0] === "status" || args[0] === "rollback" || args[0] === "scan" || args[0] === "attach" || args[0] === "install" || args[0] === "setup" || args[0] === "detach" || args[0] === "uninstall" || args[0] === "context" || args[0] === "history" || args[0] === "learn" || args[0] === "watch" || args[0] === "export" || args[0] === "import" || args[0] === "reset") {
+    if (args[0] === "status" || args[0] === "rollback" || args[0] === "scan" || args[0] === "attach" || args[0] === "install" || args[0] === "detach" || args[0] === "uninstall" || args[0] === "context" || args[0] === "history" || args[0] === "learn" || args[0] === "watch" || args[0] === "export" || args[0] === "import" || args[0] === "reset") {
         command = args.shift();
     }
     if (command === "learn") {
@@ -598,6 +1265,15 @@ export function parseOperatorCliArgs(argv) {
                 index += 1;
                 continue;
             }
+            if (arg === "--openclaw-home") {
+                const next = args[index + 1];
+                if (next === undefined) {
+                    throw new Error("--openclaw-home requires a value");
+                }
+                openclawHome = next;
+                index += 1;
+                continue;
+            }
             if (arg.startsWith("--")) {
                 throw new Error(`unknown argument for learn: ${arg}`);
             }
@@ -607,7 +1283,7 @@ export function parseOperatorCliArgs(argv) {
         }
         return {
             command,
-            activationRoot: resolveActivationRoot({ explicit: activationRoot }),
+            activationRoot: resolveCliActivationRoot(activationRoot, openclawHome),
             json,
             help
         };
@@ -663,9 +1339,12 @@ export function parseOperatorCliArgs(argv) {
         if (help) {
             return { command, activationRoot: "", scanRoot: null, interval: 30, json, help };
         }
+        if (activationRoot === null || activationRoot.trim().length === 0) {
+            throw new Error("watch requires --activation-root <path>");
+        }
         return {
             command,
-            activationRoot: resolveActivationRoot({ explicit: activationRoot }),
+            activationRoot: path.resolve(activationRoot),
             scanRoot: watchScanRoot,
             interval: watchInterval,
             json,
@@ -693,6 +1372,15 @@ export function parseOperatorCliArgs(argv) {
                 index += 1;
                 continue;
             }
+            if (arg === "--openclaw-home") {
+                const next = args[index + 1];
+                if (next === undefined) {
+                    throw new Error("--openclaw-home requires a value");
+                }
+                openclawHome = next;
+                index += 1;
+                continue;
+            }
             if (arg.startsWith("--")) {
                 throw new Error(`unknown argument for context: ${arg}`);
             }
@@ -707,7 +1395,7 @@ export function parseOperatorCliArgs(argv) {
         return {
             command,
             message: messageParts.join(" "),
-            activationRoot: resolveActivationRoot({ explicit: activationRoot }),
+            activationRoot: resolveCliActivationRoot(activationRoot, openclawHome),
             json,
             help
         };
@@ -733,6 +1421,15 @@ export function parseOperatorCliArgs(argv) {
                 index += 1;
                 continue;
             }
+            if (arg === "--openclaw-home") {
+                const next = args[index + 1];
+                if (next === undefined) {
+                    throw new Error("--openclaw-home requires a value");
+                }
+                openclawHome = next;
+                index += 1;
+                continue;
+            }
             if (arg === "--limit") {
                 const next = args[index + 1];
                 if (next === undefined) {
@@ -755,7 +1452,7 @@ export function parseOperatorCliArgs(argv) {
         }
         return {
             command,
-            activationRoot: resolveActivationRoot({ explicit: activationRoot }),
+            activationRoot: resolveCliActivationRoot(activationRoot, openclawHome),
             limit: historyLimit,
             json,
             help
@@ -781,6 +1478,14 @@ export function parseOperatorCliArgs(argv) {
                 index += 1;
                 continue;
             }
+            if (arg === "--openclaw-home") {
+                const next = args[index + 1];
+                if (next === undefined)
+                    throw new Error("--openclaw-home requires a value");
+                openclawHome = next;
+                index += 1;
+                continue;
+            }
             if (arg === "-o" || arg === "--output") {
                 const next = args[index + 1];
                 if (next === undefined)
@@ -798,7 +1503,7 @@ export function parseOperatorCliArgs(argv) {
             throw new Error("export requires -o <output.tar.gz>");
         return {
             command,
-            activationRoot: resolveActivationRoot({ explicit: activationRoot }),
+            activationRoot: resolveCliActivationRoot(activationRoot, openclawHome),
             outputPath: path.resolve(outputPath),
             json,
             help,
@@ -829,6 +1534,14 @@ export function parseOperatorCliArgs(argv) {
                 index += 1;
                 continue;
             }
+            if (arg === "--openclaw-home") {
+                const next = args[index + 1];
+                if (next === undefined)
+                    throw new Error("--openclaw-home requires a value");
+                openclawHome = next;
+                index += 1;
+                continue;
+            }
             if (arg.startsWith("--"))
                 throw new Error(`unknown argument for import: ${arg}`);
             if (archivePath === null) {
@@ -845,7 +1558,7 @@ export function parseOperatorCliArgs(argv) {
         return {
             command,
             archivePath: path.resolve(archivePath),
-            activationRoot: resolveActivationRoot({ explicit: activationRoot }),
+            activationRoot: resolveCliActivationRoot(activationRoot, openclawHome),
             force,
             json,
             help,
@@ -875,13 +1588,21 @@ export function parseOperatorCliArgs(argv) {
                 index += 1;
                 continue;
             }
+            if (arg === "--openclaw-home") {
+                const next = args[index + 1];
+                if (next === undefined)
+                    throw new Error("--openclaw-home requires a value");
+                openclawHome = next;
+                index += 1;
+                continue;
+            }
             throw new Error(`unknown argument for reset: ${arg}`);
         }
         if (help)
             return { command, activationRoot: "", yes: false, json, help };
         return {
             command,
-            activationRoot: resolveActivationRoot({ explicit: activationRoot }),
+            activationRoot: resolveCliActivationRoot(activationRoot, openclawHome),
             yes,
             json,
             help
@@ -905,6 +1626,10 @@ export function parseOperatorCliArgs(argv) {
             shared = true;
             continue;
         }
+        if (arg === "--skip-embedder-provision") {
+            skipEmbedderProvision = true;
+            continue;
+        }
         if (arg === "--keep-data") {
             keepData = true;
             continue;
@@ -1038,14 +1763,6 @@ export function parseOperatorCliArgs(argv) {
             index += 1;
             continue;
         }
-        if (arg === "--pack-root") {
-            if (next === undefined) {
-                throw new Error("--pack-root requires a value");
-            }
-            packRoot = next;
-            index += 1;
-            continue;
-        }
         if (arg === "--workspace-id") {
             if (next === undefined) {
                 throw new Error("--workspace-id requires a value");
@@ -1059,13 +1776,28 @@ export function parseOperatorCliArgs(argv) {
     if (command !== "detach" && command !== "uninstall" && restartExplicitlySet) {
         throw new Error("--restart only applies to detach/uninstall");
     }
+    if (command !== "install" && command !== "attach" && shared) {
+        throw new Error("--shared only applies to install/attach");
+    }
+    if (command !== "install" && command !== "attach" && skipEmbedderProvision) {
+        throw new Error("--skip-embedder-provision only applies to install/attach");
+    }
     if (command !== "uninstall" && keepData) {
         throw new Error("--keep-data only applies to uninstall; use detach to preserve activation data");
     }
     if (command !== "uninstall" && purgeData) {
         throw new Error("--purge-data only applies to uninstall");
     }
-    if (command === "install" || command === "setup") {
+    if (command !== "install" && command !== "attach" && workspaceId !== null) {
+        throw new Error("--workspace-id only applies to install/attach");
+    }
+    if (command !== "scan" && packLabel !== null) {
+        throw new Error("--pack-label only applies to scan --live");
+    }
+    if ((command === "install" || command === "attach") && brainAttachmentPolicy !== null) {
+        throw new Error(`${command} uses dedicated by default or --shared for shared mode; --brain-attachment-policy only applies to status/rollback inspection`);
+    }
+    if (command === "install") {
         if (help) {
             return {
                 command,
@@ -1076,13 +1808,16 @@ export function parseOperatorCliArgs(argv) {
                 shared: false,
                 workspaceId: "",
                 workspaceIdSource: "explicit",
+                skipEmbedderProvision: false,
+                skipEmbedderProvisionSource: null,
                 json,
                 help
             };
         }
-        const resolvedOpenclawHome = resolveSetupOpenClawHome(openclawHome);
-        const resolvedActivationRoot = resolveSetupActivationRoot(resolvedOpenclawHome.openclawHome, activationRoot);
-        const resolvedWorkspaceId = resolveSetupWorkspaceId(resolvedOpenclawHome.openclawHome, workspaceId);
+        const resolvedOpenclawHome = resolveInstallOpenClawHome(openclawHome);
+        const resolvedActivationRoot = resolveInstallActivationRoot(resolvedOpenclawHome.openclawHome, activationRoot);
+        const resolvedWorkspaceId = resolveInstallWorkspaceId(resolvedOpenclawHome.openclawHome, workspaceId);
+        const resolvedEmbedderProvisionSkip = resolveInstallEmbedderProvisionSkip(skipEmbedderProvision);
         return {
             command,
             openclawHome: resolvedOpenclawHome.openclawHome,
@@ -1092,6 +1827,47 @@ export function parseOperatorCliArgs(argv) {
             shared,
             workspaceId: resolvedWorkspaceId.workspaceId,
             workspaceIdSource: resolvedWorkspaceId.source,
+            skipEmbedderProvision: resolvedEmbedderProvisionSkip.skipEmbedderProvision,
+            skipEmbedderProvisionSource: resolvedEmbedderProvisionSkip.skipEmbedderProvisionSource,
+            json,
+            help
+        };
+    }
+    if (command === "attach") {
+        if (help) {
+            return {
+                command,
+                openclawHome: "",
+                openclawHomeSource: "explicit",
+                activationRoot: "",
+                activationRootSource: "explicit",
+                shared: false,
+                workspaceId: "",
+                workspaceIdSource: "explicit",
+                skipEmbedderProvision: false,
+                skipEmbedderProvisionSource: null,
+                json,
+                help
+            };
+        }
+        if (openclawHome === null || openclawHome.trim().length === 0) {
+            throw new Error("--openclaw-home is required for attach; use install for the first-time default path");
+        }
+        const resolvedOpenclawHome = path.resolve(openclawHome);
+        const resolvedActivationRoot = resolveInstallActivationRoot(resolvedOpenclawHome, activationRoot);
+        const resolvedWorkspaceId = resolveInstallWorkspaceId(resolvedOpenclawHome, workspaceId);
+        const resolvedEmbedderProvisionSkip = resolveInstallEmbedderProvisionSkip(skipEmbedderProvision);
+        return {
+            command,
+            openclawHome: resolvedOpenclawHome,
+            openclawHomeSource: "explicit",
+            activationRoot: resolvedActivationRoot.activationRoot,
+            activationRootSource: resolvedActivationRoot.source,
+            shared,
+            workspaceId: resolvedWorkspaceId.workspaceId,
+            workspaceIdSource: resolvedWorkspaceId.source,
+            skipEmbedderProvision: resolvedEmbedderProvisionSkip.skipEmbedderProvision,
+            skipEmbedderProvisionSource: resolvedEmbedderProvisionSkip.skipEmbedderProvisionSource,
             json,
             help
         };
@@ -1153,30 +1929,6 @@ export function parseOperatorCliArgs(argv) {
             help
         };
     }
-    if (command === "attach") {
-        if (help) {
-            return { command, activationRoot: "", packRoot: "", packLabel: "", workspaceId: "", brainAttachmentPolicy: null, json, help };
-        }
-        if (activationRoot === null || activationRoot.trim().length === 0) {
-            throw new Error("--activation-root is required for attach");
-        }
-        const resolvedActivationRoot = path.resolve(activationRoot);
-        const resolvedPackRoot = packRoot !== null
-            ? path.resolve(packRoot)
-            : path.resolve(resolvedActivationRoot, "packs", "initial");
-        const resolvedWorkspaceId = workspaceId ?? "workspace";
-        const resolvedPackLabel = packLabel ?? "cli-attach";
-        return {
-            command,
-            activationRoot: resolvedActivationRoot,
-            packRoot: resolvedPackRoot,
-            packLabel: resolvedPackLabel,
-            workspaceId: resolvedWorkspaceId,
-            brainAttachmentPolicy: brainAttachmentPolicy,
-            json,
-            help
-        };
-    }
     if (command === "scan") {
         if ((sessionPath === null && livePath === null) || (sessionPath !== null && livePath !== null)) {
             throw new Error("scan requires exactly one of --session or --live");
@@ -1219,6 +1971,7 @@ export function parseOperatorCliArgs(argv) {
             updatedAt,
             brainAttachmentPolicy
         },
+        openclawHome: normalizeOptionalCliString(openclawHome),
         json,
         help,
         dryRun,
@@ -1259,6 +2012,7 @@ function resolveExtensionRuntimeGuardPath() {
         path.resolve(__dirname, "..", "..", "extension", "runtime-guard.ts"),
     ];
     const jsCandidates = [
+        path.resolve(__dirname, "..", "dist", "extension", "runtime-guard.js"),
         path.resolve(__dirname, "extension", "runtime-guard.js"),
         path.resolve(__dirname, "..", "extension", "runtime-guard.js"),
     ];
@@ -1282,6 +2036,36 @@ const LOCAL_WORKSPACE_EXTENSION_PACKAGES = [
     "provenance",
     "workspace-metadata"
 ];
+const OPENCLAWBRAIN_EXTENSION_TARBALL_DIR_ENV = "OPENCLAWBRAIN_EXTENSION_TARBALL_DIR";
+function resolveNpmCommand() {
+    return process.platform === "win32" ? "npm.cmd" : "npm";
+}
+function resolveExtensionInstallReleaseTarballs() {
+    const configuredDir = normalizeOptionalCliString(process.env[OPENCLAWBRAIN_EXTENSION_TARBALL_DIR_ENV]);
+    if (configuredDir === null) {
+        return null;
+    }
+    const artifactDir = path.resolve(configuredDir);
+    let entries;
+    try {
+        entries = readdirSync(artifactDir, { withFileTypes: true });
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new Error(`${OPENCLAWBRAIN_EXTENSION_TARBALL_DIR_ENV} is unreadable: ${artifactDir} (${detail})`);
+    }
+    const tarballs = entries
+        .filter((entry) => entry.isFile() && entry.name.endsWith(".tgz"))
+        .map((entry) => path.join(artifactDir, entry.name))
+        .sort((left, right) => left.localeCompare(right));
+    if (tarballs.length === 0) {
+        throw new Error(`${OPENCLAWBRAIN_EXTENSION_TARBALL_DIR_ENV} has no .tgz release artifacts: ${artifactDir}`);
+    }
+    return {
+        artifactDir,
+        tarballs
+    };
+}
 function resolveLocalWorkspaceRootForExtensionInstall() {
     const candidates = [
         path.resolve(__dirname, "..", "..", "..", ".."),
@@ -1458,6 +2242,85 @@ function buildHistoryEntry(record, slot, isActive) {
         current: isActive
     };
 }
+function formatInspectionFindings(findings) {
+    return findings.join("; ");
+}
+function buildInstallRefusalError(parsed, detail) {
+    const purgeCommand = `openclawbrain uninstall --openclaw-home ${quoteShellArg(parsed.openclawHome)} ` +
+        `--activation-root ${quoteShellArg(parsed.activationRoot)} --purge-data`;
+    return new Error(`Refusing to reuse activation root ${path.resolve(parsed.activationRoot)}: ${detail}. ` +
+        "Install only repairs an empty first-state root; it will not overwrite populated or broken activation state. " +
+        `Inspect: ${buildInstallStatusCommand(parsed.activationRoot)}. ` +
+        `Reset: ${purgeCommand}.`);
+}
+function inspectInstallActivationPlan(parsed) {
+    const resolvedActivationRoot = path.resolve(parsed.activationRoot);
+    const activationPointersPath = path.join(resolvedActivationRoot, "activation-pointers.json");
+    if (!existsSync(resolvedActivationRoot)) {
+        return {
+            createActivationRoot: true,
+            action: "bootstrap",
+            resolution: "new_root",
+            inspectionStep: "Activation state inspection: activation root is missing; bootstrapping first state.",
+            activePackId: null
+        };
+    }
+    const activationRootStats = statSync(resolvedActivationRoot);
+    if (!activationRootStats.isDirectory()) {
+        throw buildInstallRefusalError(parsed, "activation root path exists but is not a directory");
+    }
+    if (!existsSync(activationPointersPath)) {
+        return {
+            createActivationRoot: false,
+            action: "bootstrap",
+            resolution: "missing_pointers",
+            inspectionStep: "Activation state inspection: activation root exists but activation-pointers.json is missing; bootstrapping first state.",
+            activePackId: null
+        };
+    }
+    let inspection;
+    try {
+        inspection = inspectActivationState(resolvedActivationRoot, new Date().toISOString());
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        throw buildInstallRefusalError(parsed, `activation pointers could not be inspected (${detail})`);
+    }
+    if (inspection.active === null && inspection.candidate === null && inspection.previous === null) {
+        return {
+            createActivationRoot: false,
+            action: "bootstrap",
+            resolution: "empty_pointers",
+            inspectionStep: "Activation state inspection: activation pointers are present but all slots are empty; bootstrapping first state.",
+            activePackId: null
+        };
+    }
+    const unhealthySlots = [inspection.active, inspection.candidate, inspection.previous]
+        .filter((slot) => slot !== null && !slot.activationReady)
+        .map((slot) => `${slot.slot}: ${formatInspectionFindings(slot.findings)}`);
+    if (unhealthySlots.length > 0) {
+        throw buildInstallRefusalError(parsed, `activation state contains unhealthy slots (${unhealthySlots.join(" | ")})`);
+    }
+    if (inspection.active === null) {
+        const populatedSlots = [inspection.candidate, inspection.previous]
+            .filter((slot) => slot !== null)
+            .map((slot) => slot.slot);
+        throw buildInstallRefusalError(parsed, `activation state is populated without an active pack (${populatedSlots.join(", ")})`);
+    }
+    if (inspection.candidate !== null && !inspection.promotion.allowed) {
+        throw buildInstallRefusalError(parsed, `candidate slot is stale or incoherent (${formatInspectionFindings(inspection.promotion.findings)})`);
+    }
+    if (inspection.previous !== null && !inspection.rollback.allowed) {
+        throw buildInstallRefusalError(parsed, `previous slot is stale or incoherent (${formatInspectionFindings(inspection.rollback.findings)})`);
+    }
+    return {
+        createActivationRoot: false,
+        action: "keep",
+        resolution: "healthy_existing",
+        inspectionStep: `Activation state inspection: active pack ${inspection.active.packId} is healthy; keeping existing activation state.`,
+        activePackId: inspection.active.packId
+    };
+}
 function runHistoryCommand(parsed) {
     const activationRoot = parsed.activationRoot;
     const pointersPath = path.join(activationRoot, "activation-pointers.json");
@@ -1539,29 +2402,53 @@ function runHistoryCommand(parsed) {
     }
     return 0;
 }
-function runSetupCommand(parsed) {
+function runProfileHookAttachCommand(parsed) {
     const steps = [];
     const commandLabel = parsed.command.toUpperCase();
-    const activationRootCreated = !existsSync(parsed.activationRoot);
-    let bootstrapped = false;
-    steps.push(`Target OpenClaw profile home: ${parsed.openclawHome} (${formatSetupOpenClawHomeSource(parsed.openclawHomeSource)})`);
+    const isInstall = parsed.command === "install";
+    const targetInspection = inspectOpenClawHome(parsed.openclawHome);
+    const extensionDir = path.join(parsed.openclawHome, "extensions", "openclawbrain");
+    steps.push(`Target OpenClaw home: ${parsed.openclawHome} (${formatInstallOpenClawHomeSource(parsed.openclawHomeSource)})`);
+    steps.push(isInstall
+        ? "Lifecycle mode: install is the safe first-time default for wiring one profile to one activation root."
+        : "Lifecycle mode: attach is the explicit reattach/manual profile-hook path; use install for first-time setup.");
+    steps.push(`Detected layout: ${formatOpenClawTargetExplanation(targetInspection)}`);
+    steps.push(`Target hook path: ${extensionDir}`);
     // 1. Validate --openclaw-home exists and has openclaw.json
     validateOpenClawHome(parsed.openclawHome);
-    // 2. Create activation root if needed
-    if (activationRootCreated) {
+    // 2. Inspect the activation root before writing profile hook artifacts.
+    const activationPlan = inspectInstallActivationPlan(parsed);
+    // 3. Ensure the default embedder exists before bootstrap unless the operator explicitly opts out.
+    const embedderProvision = activationPlan.action === "bootstrap"
+        ? ensureInstallEmbedderReady(parsed)
+        : null;
+    if (embedderProvision === null) {
+        steps.push("Skipped bootstrap-time embedder provisioning because attach/install is reusing healthy activation state.");
+    }
+    else {
+        steps.push(embedderProvision.detail);
+    }
+    // 4. Create activation root if needed
+    if (activationPlan.createActivationRoot) {
         mkdirSync(parsed.activationRoot, { recursive: true });
         steps.push(`Created activation root: ${parsed.activationRoot}`);
     }
     else {
         steps.push(`Activation root exists: ${parsed.activationRoot}`);
     }
-    // 3. Run bootstrapRuntimeAttach if not already attached
-    const activationPointersPath = path.join(parsed.activationRoot, "activation-pointers.json");
-    if (existsSync(activationPointersPath)) {
-        steps.push("Brain already attached (activation-pointers.json exists), skipping bootstrap.");
+    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"
+        ? writeInstallProviderDefaults(parsed)
+        : null;
+    if (providerDefaults === null) {
+        steps.push("Skipped provider-default refresh because explicit attach is reusing existing activation data.");
     }
     else {
-        bootstrapped = true;
+        steps.push(providerDefaults.detail);
+    }
+    // 6. Bootstrap only for safe empty first-state roots; otherwise keep the inspected healthy state.
+    if (activationPlan.action === "bootstrap") {
         const packRoot = path.resolve(parsed.activationRoot, "packs", "initial");
         mkdirSync(packRoot, { recursive: true });
         const brainAttachmentPolicy = parsed.shared ? "shared" : "dedicated";
@@ -1570,27 +2457,31 @@ function runSetupCommand(parsed) {
             brainAttachmentPolicy,
             activationRoot: parsed.activationRoot,
             packRoot,
-            packLabel: "setup-cli",
+            packLabel: isInstall ? "install-cli" : "attach-cli",
             workspace: {
                 workspaceId: parsed.workspaceId,
-                snapshotId: `${parsed.workspaceId}@setup-${new Date().toISOString().slice(0, 10)}`,
+                snapshotId: `${parsed.workspaceId}@${parsed.command}-${new Date().toISOString().slice(0, 10)}`,
                 capturedAt: new Date().toISOString(),
                 rootDir: parsed.openclawHome,
-                revision: "cli-setup-v1"
+                revision: isInstall ? "cli-install-v1" : "cli-attach-v1"
             },
             interactionEvents: [],
             feedbackEvents: []
         });
-        steps.push(`Bootstrapped brain attach: ${result.status}`);
+        steps.push(`Bootstrapped brain attach: state=${result.currentProfile.brain.state} awaitingFirstExport=${yesNo(result.currentProfile.brainStatus.awaitingFirstExport)}`);
     }
-    // 4-7. Write extension files
-    const extensionDir = path.join(parsed.openclawHome, "extensions", "openclawbrain");
+    else {
+        steps.push(isInstall
+            ? `Kept inspected activation state: active pack ${activationPlan.activePackId}`
+            : `Reused inspected activation state for explicit attach: active pack ${activationPlan.activePackId}`);
+    }
+    // 7-10. Write extension files
     mkdirSync(extensionDir, { recursive: true });
-    // 4. Write index.ts
+    // 5. Write index.ts
     const indexTsPath = path.join(extensionDir, "index.ts");
     writeFileSync(indexTsPath, buildExtensionIndexTs(parsed.activationRoot), "utf8");
     steps.push(`Wrote extension: ${indexTsPath}`);
-    // 4b. Write runtime-guard files (imported by index.ts as ./runtime-guard.js)
+    // 5b. Write runtime-guard files (imported by index.ts as ./runtime-guard.js)
     const runtimeGuardPaths = resolveExtensionRuntimeGuardPath();
     if (runtimeGuardPaths.ts !== null) {
         const runtimeGuardTsPath = path.join(extensionDir, "runtime-guard.ts");
@@ -1600,17 +2491,31 @@ function runSetupCommand(parsed) {
     const runtimeGuardJsPath = path.join(extensionDir, "runtime-guard.js");
     writeFileSync(runtimeGuardJsPath, readFileSync(runtimeGuardPaths.js, "utf8"), "utf8");
     steps.push(`Wrote extension runtime-guard: ${runtimeGuardJsPath}`);
-    // 5. Write package.json
+    // 6. Write package.json
     const packageJsonPath = path.join(extensionDir, "package.json");
     writeFileSync(packageJsonPath, buildExtensionPackageJson(), "utf8");
     steps.push(`Wrote package.json: ${packageJsonPath}`);
-    // 6. npm install
+    // 7. npm install
+    const releaseTarballInstall = resolveExtensionInstallReleaseTarballs();
     try {
-        execSync("npm install --ignore-scripts", { cwd: extensionDir, stdio: "pipe" });
-        steps.push("Ran npm install --ignore-scripts");
+        if (releaseTarballInstall !== null) {
+            execFileSync(resolveNpmCommand(), ["install", "--ignore-scripts", "--no-save", ...releaseTarballInstall.tarballs], { cwd: extensionDir, stdio: "pipe" });
+            steps.push(`Installed extension dependencies from release artifacts: ${releaseTarballInstall.tarballs.length} tarballs from ${releaseTarballInstall.artifactDir}`);
+        }
+        else {
+            execSync("npm install --ignore-scripts", { cwd: extensionDir, stdio: "pipe" });
+            steps.push("Ran npm install --ignore-scripts");
+            const linkedPackages = installExtensionFromLocalWorkspaceBuild(extensionDir);
+            if (linkedPackages !== null) {
+                steps.push(`Linked coherent local workspace packages: ${linkedPackages.join(", ")}`);
+            }
+        }
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
+        if (releaseTarballInstall !== null) {
+            throw new Error(`Extension dependency install from release artifacts failed: ${message}`);
+        }
         const linkedPackages = installExtensionFromLocalWorkspaceBuild(extensionDir);
         if (linkedPackages !== null) {
             steps.push(`Linked coherent local workspace packages: ${linkedPackages.join(", ")}`);
@@ -1619,109 +2524,83 @@ function runSetupCommand(parsed) {
             steps.push(`npm install failed (non-fatal): ${message}`);
         }
     }
-    // 7. Write plugin manifest
+    // 8. Write plugin manifest
     const manifestPath = path.join(extensionDir, "openclaw.plugin.json");
     writeFileSync(manifestPath, buildExtensionPluginManifest(), "utf8");
     steps.push(`Wrote manifest: ${manifestPath}`);
-    // 8. Write BRAIN.md to workspace directories
-    const brainMdContent = [
-        "## OpenClawBrain",
-        `You have a learning brain attached at ${parsed.activationRoot}.`,
-        "- It learns automatically from your conversations",
-        '- Corrections matter — "no, actually X" teaches the brain X',
-        "- You don't manage it — background daemon handles learning",
-        "- Check: `openclawbrain status`",
-        "- Rollback: `openclawbrain rollback`",
-        '- See what brain knows: `openclawbrain context "your question"`',
-        ""
-    ].join("\n");
-    const agentsMdBrainRef = "\n5. Read `BRAIN.md` — your learning brain context\n";
-    try {
-        const entries = readdirSync(parsed.openclawHome, { withFileTypes: true });
-        const workspaceDirs = entries
-            .filter(e => e.isDirectory() && e.name.startsWith("workspace-"))
-            .map(e => path.join(parsed.openclawHome, e.name));
-        // If no workspace-* dirs found, check if openclawHome itself is a workspace
-        if (workspaceDirs.length === 0) {
-            workspaceDirs.push(parsed.openclawHome);
-        }
-        for (const wsDir of workspaceDirs) {
-            const brainMdPath = path.join(wsDir, "BRAIN.md");
-            writeFileSync(brainMdPath, brainMdContent, "utf8");
-            steps.push(`Wrote BRAIN.md: ${brainMdPath}`);
-            // If AGENTS.md exists, append brain reference to startup sequence
-            const agentsMdPath = path.join(wsDir, "AGENTS.md");
-            if (existsSync(agentsMdPath)) {
-                const agentsContent = readFileSync(agentsMdPath, "utf8");
-                if (!agentsContent.includes("BRAIN.md")) {
-                    // Find the startup sequence section and append after the last numbered item
-                    const startupMarker = "## Session Startup";
-                    if (agentsContent.includes(startupMarker)) {
-                        // Find the numbered list in the startup section and append after last item
-                        const lines = agentsContent.split("\n");
-                        let lastNumberedIdx = -1;
-                        let inStartup = false;
-                        for (let i = 0; i < lines.length; i++) {
-                            const line = lines[i] ?? "";
-                            if (line.includes(startupMarker)) {
-                                inStartup = true;
-                                continue;
-                            }
-                            if (inStartup && /^\d+\.\s/.test(line.trim())) {
-                                lastNumberedIdx = i;
-                            }
-                            if (inStartup && line.startsWith("## ") && !line.includes(startupMarker)) {
-                                break;
-                            }
-                        }
-                        if (lastNumberedIdx >= 0) {
-                            lines.splice(lastNumberedIdx + 1, 0, agentsMdBrainRef.trimEnd());
-                            writeFileSync(agentsMdPath, lines.join("\n"), "utf8");
-                            steps.push(`Updated AGENTS.md startup sequence: ${agentsMdPath}`);
-                        }
-                        else {
-                            appendFileSync(agentsMdPath, agentsMdBrainRef, "utf8");
-                            steps.push(`Appended BRAIN.md reference to AGENTS.md: ${agentsMdPath}`);
-                        }
-                    }
-                    else {
-                        appendFileSync(agentsMdPath, agentsMdBrainRef, "utf8");
-                        steps.push(`Appended BRAIN.md reference to AGENTS.md: ${agentsMdPath}`);
-                    }
-                }
-                else {
-                    steps.push(`AGENTS.md already references BRAIN.md: ${agentsMdPath}`);
-                }
-            }
-        }
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        steps.push(`BRAIN.md generation failed (non-fatal): ${message}`);
-    }
     const restartGuidance = buildInstallReloadGuidance();
     const nextSteps = [
         restartGuidance,
-        `Check status: ${buildInstallStatusCommand(parsed.activationRoot)}`
+        `Check status: ${buildInstallStatusCommand(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)}`,
+        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`,
+        embedderProvision === null
+            ? "Embedder: unchanged because no bootstrap was needed"
+            : embedderProvision.state === "ensured"
+                ? `Embedder: default Ollama model ${embedderProvision.model} was ensured before bootstrap`
+                : `Embedder: default Ollama model ${embedderProvision.model} was intentionally skipped`,
+        `Serve path: install alone does not prove serving; restart the profile and run ${buildInstallStatusCommand(parsed.activationRoot)}`
     ];
     const lifecycleSummary = [
-        `OpenClaw profile: ${shortenPath(parsed.openclawHome)} (${formatSetupOpenClawHomeSource(parsed.openclawHomeSource)})`,
-        `Activation root: ${shortenPath(parsed.activationRoot)} (${formatSetupActivationRootSource(parsed.activationRootSource)})`,
-        `Workspace ID: ${parsed.workspaceId} (${formatSetupWorkspaceIdSource(parsed.workspaceIdSource)})`,
+        isInstall
+            ? "Lifecycle mode: install (safe first-time/default profile hookup)"
+            : "Lifecycle mode: attach (explicit reattach/manual profile hookup)",
+        `OpenClaw target: ${shortenPath(parsed.openclawHome)} (${formatInstallOpenClawHomeSource(parsed.openclawHomeSource)})`,
+        `Detected layout: ${formatOpenClawTargetExplanation(targetInspection)}`,
+        `Activation root: ${shortenPath(parsed.activationRoot)} (${formatInstallActivationRootSource(parsed.activationRootSource)})`,
+        `Workspace ID: ${parsed.workspaceId} (${formatInstallWorkspaceIdSource(parsed.workspaceIdSource)})`,
+        embedderProvision === null
+            ? "Embedder: unchanged because no bootstrap was needed"
+            : embedderProvision.state === "ensured"
+                ? `Embedder: ensured default Ollama model ${embedderProvision.model} before brain init`
+                : `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)}`,
-        activationRootCreated
+        activationPlan.resolution === "new_root"
             ? `Activation data: initialized at ${shortenPath(parsed.activationRoot)}`
-            : `Activation data: reused at ${shortenPath(parsed.activationRoot)}`,
-        bootstrapped
-            ? "Brain attach: bootstrapped a seed/current-profile attach"
-            : "Brain attach: existing activation state kept in place"
+            : activationPlan.resolution === "missing_pointers"
+                ? `Activation data: repaired missing pointers at ${shortenPath(parsed.activationRoot)}`
+                : activationPlan.resolution === "empty_pointers"
+                    ? `Activation data: repaired empty pointers at ${shortenPath(parsed.activationRoot)}`
+                    : `Activation data: reused healthy state at ${shortenPath(parsed.activationRoot)}`,
+        activationPlan.action === "bootstrap"
+            ? activationPlan.resolution === "new_root"
+                ? `${isInstall ? "Install" : "Attach"}: bootstrapped a seed/current-profile brain`
+                : activationPlan.resolution === "missing_pointers"
+                    ? `${isInstall ? "Install" : "Attach"}: repaired missing activation pointers and bootstrapped a seed/current-profile brain`
+                    : `${isInstall ? "Install" : "Attach"}: repaired empty activation pointers and bootstrapped a seed/current-profile brain`
+            : isInstall
+                ? `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({
             command: parsed.command,
             openclawHome: parsed.openclawHome,
             openclawHomeSource: parsed.openclawHomeSource,
+            openclawTarget: {
+                layout: targetInspection.layout,
+                detail: describeOpenClawHomeInspection(targetInspection),
+                profileId: targetInspection.profileId,
+                profileSource: targetInspection.profileSource,
+                configuredProfileIds: targetInspection.configuredProfileIds
+            },
             activationRoot: parsed.activationRoot,
             resolvedInputs: {
                 activationRoot: {
@@ -1735,8 +2614,47 @@ function runSetupCommand(parsed) {
             },
             workspaceId: parsed.workspaceId,
             shared: parsed.shared,
+            embedderProvision: embedderProvision === null
+                ? null
+                : {
+                    skipped: parsed.skipEmbedderProvision,
+                    source: parsed.skipEmbedderProvisionSource,
+                    model: embedderProvision.model,
+                    baseUrl: embedderProvision.baseUrl
+                },
+            providerDefaults: providerDefaults === null
+                ? null
+                : {
+                    path: providerDefaults.path,
+                    teacher: providerDefaults.defaults.teacher === undefined
+                        ? null
+                        : {
+                            provider: providerDefaults.defaults.teacher.provider ?? null,
+                            model: providerDefaults.defaults.teacher.model ?? null,
+                            detectedLocally: providerDefaults.defaults.teacher.detectedLocally ?? false
+                        },
+                    embedder: providerDefaults.defaults.embedder === undefined
+                        ? null
+                        : {
+                            provider: providerDefaults.defaults.embedder.provider ?? null,
+                            model: providerDefaults.defaults.embedder.model ?? null
+                        },
+                    teacherBaseUrl: providerDefaults.defaults.teacherBaseUrl ?? null,
+                    embedderBaseUrl: providerDefaults.defaults.embedderBaseUrl ?? null
+                },
+            brainFeedback: {
+                hookPath: brainFeedback.hookPath,
+                providerDefaultsPath: brainFeedback.providerDefaultsPath,
+                embedder: brainFeedback.embedder,
+                teacher: brainFeedback.teacher,
+                startup: brainFeedback.startup,
+                provedNow: brainFeedback.provedNow,
+                notYetProved: brainFeedback.notYetProved,
+                lines: brainFeedback.lines
+            },
             extensionDir,
             lifecycleSummary,
+            preflightSummary,
             restartGuidance,
             nextSteps,
             steps
@@ -1744,19 +2662,24 @@ function runSetupCommand(parsed) {
     }
     else {
         console.log(`${commandLabel} complete\n`);
-        for (const step of steps) {
-            console.log(`  ✓ ${step}`);
-        }
-        console.log("");
-        console.log("Lifecycle:");
-        for (const line of lifecycleSummary) {
+        console.log("Brain feedback:");
+        for (const line of brainFeedback.lines) {
             console.log(`  ${line}`);
         }
         console.log(`Next:       ${restartGuidance}`);
         console.log(`Check:      ${buildInstallStatusCommand(parsed.activationRoot)}`);
+        if (embedderProvision !== null && embedderProvision.state === "skipped") {
+            console.log(`Embedder:   ${buildInstallEmbedderProvisionCommand(embedderProvision.baseUrl, embedderProvision.model)}`);
+        }
     }
     return 0;
 }
+function runInstallCommand(parsed) {
+    return runProfileHookAttachCommand(parsed);
+}
+function runAttachCommand(parsed) {
+    return runProfileHookAttachCommand(parsed);
+}
 function validateOpenClawHome(openclawHome) {
     if (!existsSync(openclawHome)) {
         throw new Error(`--openclaw-home directory does not exist: ${openclawHome}`);
@@ -1806,25 +2729,43 @@ function buildRestartGuidance(restart) {
 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);
     const extensionDir = removeProfileHookup(parsed.openclawHome, steps);
+    const legacyResidue = removeLegacyProfileResidue(parsed.openclawHome);
     const activationData = summarizeKeptActivationData(activationRoot);
     const restartGuidance = buildRestartGuidance(parsed.restart);
     const nextSteps = [
         restartGuidance,
         activationRoot === null ? null : `Inspect preserved data: ${buildInstallStatusCommand(activationRoot)}`,
-        `Reattach later: ${buildInstallCommand(parsed.openclawHome)}`
+        `Reattach later: ${buildAttachCommand(parsed.openclawHome, activationRoot)}`
     ].filter((step) => step !== null);
+    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(activationData.activationDataDetail);
     steps.push("Detach only removes the OpenClaw profile hook; it does not delete OpenClawBrain data.");
     if (parsed.json) {
         console.log(JSON.stringify({
             command: "detach",
             openclawHome: parsed.openclawHome,
+            openclawTarget: {
+                layout: targetInspection.layout,
+                detail: describeOpenClawHomeInspection(targetInspection),
+                profileId: targetInspection.profileId,
+                profileSource: targetInspection.profileSource,
+                configuredProfileIds: targetInspection.configuredProfileIds
+            },
             extensionDir,
             activationRoot,
             dataAction: "kept",
             activationDataState: activationData.activationDataState,
+            removedLegacyNotes: legacyResidue.removedNotes,
+            updatedAgents: legacyResidue.updatedAgents,
             restartMode: parsed.restart,
             restartGuidance,
             nextSteps,
@@ -1837,7 +2778,8 @@ function runDetachCommand(parsed) {
             console.log(`  ✓ ${step}`);
         }
         console.log("");
-        console.log(`Lifecycle:     OpenClaw profile ${shortenPath(parsed.openclawHome)} is detached from the brain hook.`);
+        console.log(`Lifecycle:     OpenClaw home ${shortenPath(parsed.openclawHome)} is detached from the brain hook.`);
+        console.log(`Target:        ${formatOpenClawTargetExplanation(targetInspection)}`);
         if (activationRoot !== null) {
             console.log(`Brain data:    ${shortenPath(activationRoot)} remains available for inspection or reattach.`);
         }
@@ -1848,15 +2790,18 @@ function runDetachCommand(parsed) {
         if (activationRoot !== null) {
             console.log(`Check:         ${buildInstallStatusCommand(activationRoot)}`);
         }
-        console.log(`Reattach:      ${buildInstallCommand(parsed.openclawHome)}`);
+        console.log(`Reattach:      ${buildAttachCommand(parsed.openclawHome, activationRoot)}`);
     }
     return 0;
 }
 function runUninstallCommand(parsed) {
     const steps = [];
     validateOpenClawHome(parsed.openclawHome);
+    const targetInspection = inspectOpenClawHome(parsed.openclawHome);
+    steps.push(`Detected layout: ${formatOpenClawTargetExplanation(targetInspection)}`);
     const activationRoot = resolveCleanupActivationRoot(parsed.openclawHome, parsed.activationRoot);
     const extensionDir = removeProfileHookup(parsed.openclawHome, steps);
+    const legacyResidue = removeLegacyProfileResidue(parsed.openclawHome);
     let activationData;
     if (parsed.dataMode === "purge") {
         if (activationRoot === null) {
@@ -1885,8 +2830,16 @@ function runUninstallCommand(parsed) {
     const nextSteps = [
         restartGuidance,
         parsed.dataMode === "keep" && activationRoot !== null ? `Inspect preserved data: ${buildInstallStatusCommand(activationRoot)}` : null,
-        `Reinstall later: ${buildInstallCommand(parsed.openclawHome)}`
+        parsed.dataMode === "keep"
+            ? `Reattach later: ${buildAttachCommand(parsed.openclawHome, activationRoot)}`
+            : `Reinstall later: ${buildInstallCommand(parsed.openclawHome)}`
     ].filter((step) => step !== null);
+    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(activationData.activationDataDetail);
     steps.push(parsed.dataMode === "purge"
         ? "Uninstall removed the OpenClaw profile hook and activation data."
@@ -1895,10 +2848,19 @@ function runUninstallCommand(parsed) {
         console.log(JSON.stringify({
             command: "uninstall",
             openclawHome: parsed.openclawHome,
+            openclawTarget: {
+                layout: targetInspection.layout,
+                detail: describeOpenClawHomeInspection(targetInspection),
+                profileId: targetInspection.profileId,
+                profileSource: targetInspection.profileSource,
+                configuredProfileIds: targetInspection.configuredProfileIds
+            },
             extensionDir,
             activationRoot,
             dataAction: parsed.dataMode,
             activationDataState: activationData.activationDataState,
+            removedLegacyNotes: legacyResidue.removedNotes,
+            updatedAgents: legacyResidue.updatedAgents,
             restartMode: parsed.restart,
             restartGuidance,
             nextSteps,
@@ -1911,7 +2873,8 @@ function runUninstallCommand(parsed) {
             console.log(`  ✓ ${step}`);
         }
         console.log("");
-        console.log(`Lifecycle:     OpenClaw profile ${shortenPath(parsed.openclawHome)} no longer has the brain hook installed.`);
+        console.log(`Lifecycle:     OpenClaw home ${shortenPath(parsed.openclawHome)} no longer has the brain hook installed.`);
+        console.log(`Target:        ${formatOpenClawTargetExplanation(targetInspection)}`);
         console.log(`Data mode:     ${parsed.dataMode === "purge" ? "purged" : "kept"}`);
         if (activationRoot !== null) {
             console.log(`Activation:    ${parsed.dataMode === "purge" ? shortenPath(activationRoot) : `${shortenPath(activationRoot)} preserved`}`);
@@ -1920,7 +2883,12 @@ function runUninstallCommand(parsed) {
         if (parsed.dataMode === "keep" && activationRoot !== null) {
             console.log(`Check:         ${buildInstallStatusCommand(activationRoot)}`);
         }
-        console.log(`Reinstall:     ${buildInstallCommand(parsed.openclawHome)}`);
+        if (parsed.dataMode === "keep") {
+            console.log(`Reattach:      ${buildAttachCommand(parsed.openclawHome, activationRoot)}`);
+        }
+        else {
+            console.log(`Reinstall:     ${buildInstallCommand(parsed.openclawHome)}`);
+        }
     }
     return 0;
 }
@@ -2341,16 +3309,9 @@ function formatTimestamp() {
 function watchLog(message) {
     console.log(`${formatTimestamp()} ${message}`);
 }
-function resolveOperatorTeacherSnapshotPath(activationRoot, explicitPath) {
-    if (explicitPath !== null && explicitPath !== undefined) {
-        return explicitPath;
-    }
-    const asyncSnapshotPath = resolveAsyncTeacherLiveLoopSnapshotPath(activationRoot);
-    return existsSync(asyncSnapshotPath) ? asyncSnapshotPath : null;
+function formatWatchError(error) {
+    return error instanceof Error ? error.message : String(error);
 }
-const WATCH_STATE_DIRNAME = "watch";
-const WATCH_SESSION_TAIL_CURSOR_BASENAME = "session-tail-cursor.json";
-const WATCH_TEACHER_SNAPSHOT_BASENAME = "teacher-snapshot.json";
 function sanitizeWatchPathSegment(value) {
     const sanitized = value
         .replace(/[^a-zA-Z0-9._-]+/g, "-")
@@ -2358,15 +3319,6 @@ function sanitizeWatchPathSegment(value) {
         .slice(0, 96);
     return sanitized.length > 0 ? sanitized : "session";
 }
-function resolveWatchStateRoot(activationRoot) {
-    return path.resolve(activationRoot, WATCH_STATE_DIRNAME);
-}
-function resolveWatchSessionTailCursorPath(activationRoot) {
-    return path.join(resolveWatchStateRoot(activationRoot), WATCH_SESSION_TAIL_CURSOR_BASENAME);
-}
-function resolveWatchTeacherSnapshotPath(activationRoot) {
-    return path.join(resolveWatchStateRoot(activationRoot), WATCH_TEACHER_SNAPSHOT_BASENAME);
-}
 function readOptionalJsonFile(filePath) {
     if (!existsSync(filePath)) {
         return null;
@@ -2400,28 +3352,8 @@ function persistWatchSessionTailCursor(cursorPath, cursor) {
         cursor
     });
 }
-function loadWatchTeacherSnapshotState(snapshotPath) {
-    const parsed = readOptionalJsonFile(snapshotPath);
-    return {
-        lastHandledMaterializationPackId: parsed !== null && typeof parsed.lastHandledMaterializationPackId === "string"
-            ? parsed.lastHandledMaterializationPackId
-            : null
-    };
-}
-function persistWatchTeacherSnapshot(snapshotPath, input) {
-    writeJsonFile(snapshotPath, {
-        contract: "openclaw_watch_teacher_snapshot.v1",
-        runtimeOwner: "openclaw",
-        updatedAt: new Date().toISOString(),
-        scanRoot: input.scanRoot,
-        replayedBundleCount: input.replayedBundleCount,
-        replayedEventCount: input.replayedEventCount,
-        exportedBundleCount: input.exportedBundleCount,
-        exportedEventCount: input.exportedEventCount,
-        localSessionTailNoopReason: input.localSessionTailNoopReason,
-        lastHandledMaterializationPackId: input.lastHandledMaterializationPackId,
-        snapshot: input.snapshot
-    });
+function countWatchCursorBridgedEvents(cursor) {
+    return cursor.reduce((sum, entry) => sum + entry.bridgedEventCount, 0);
 }
 function listWatchRuntimeEventExportBundleRoots(scanRoot) {
     if (!existsSync(scanRoot)) {
@@ -2528,7 +3460,8 @@ function applyWatchMaterialization(activationRoot, snapshot, lastHandledMaterial
         return {
             lastHandledMaterializationPackId,
             logLine: null,
-            materializedPackId: null
+            materializedPackId: null,
+            failure: null
         };
     }
     const packId = typeof materialization?.candidate?.summary?.packId === "string"
@@ -2538,14 +3471,28 @@ function applyWatchMaterialization(activationRoot, snapshot, lastHandledMaterial
         return {
             lastHandledMaterializationPackId,
             logLine: null,
-            materializedPackId: packId
+            materializedPackId: packId,
+            failure: null
         };
     }
     const shortPackId = packId.length > 16 ? packId.slice(0, 16) : packId;
     try {
         const candidateRootDir = path.resolve(activationRoot, "packs", packId);
         mkdirSync(candidateRootDir, { recursive: true });
-        materializeAlwaysOnLearningCandidatePack(candidateRootDir, materialization);
+        let activeBeforePack = null;
+        try {
+            activeBeforePack = loadPackFromActivation(activationRoot, "active", { requireActivationReady: true });
+        }
+        catch {
+            activeBeforePack = null;
+        }
+        const candidateDescriptor = materializeAlwaysOnLearningCandidatePack(candidateRootDir, materialization);
+        appendLearningUpdateLogs({
+            activationRoot,
+            materialization,
+            activeBeforePack,
+            candidateDescriptor
+        });
         const now = new Date().toISOString();
         stageCandidatePack(activationRoot, candidateRootDir, {
             updatedAt: now,
@@ -2560,13 +3507,15 @@ function applyWatchMaterialization(activationRoot, snapshot, lastHandledMaterial
             return {
                 lastHandledMaterializationPackId: packId,
                 materializedPackId: packId,
-                logLine: `Promoted ${shortPackId} → active`
+                logLine: `Promoted ${shortPackId} → active`,
+                failure: null
             };
         }
         return {
             lastHandledMaterializationPackId: packId,
             materializedPackId: packId,
-            logLine: `Staged ${shortPackId} (promotion blocked: ${inspection.promotion.findings.join(", ")})`
+            logLine: `Staged ${shortPackId} (promotion blocked: ${inspection.promotion.findings.join(", ")})`,
+            failure: null
         };
     }
     catch (error) {
@@ -2574,26 +3523,80 @@ function applyWatchMaterialization(activationRoot, snapshot, lastHandledMaterial
         return {
             lastHandledMaterializationPackId,
             materializedPackId: packId,
-            logLine: `Promotion failed for ${shortPackId}: ${message}`
+            logLine: `Promotion failed for ${shortPackId}: ${message}`,
+            failure: {
+                mode: "materialization_failed",
+                detail: message,
+                at: new Date().toISOString()
+            }
         };
     }
 }
+function resolveWatchTeacherLabelerConfig(input, activationRoot) {
+    if (input !== undefined) {
+        return {
+            teacherLabeler: input,
+            warnings: []
+        };
+    }
+    const providerConfig = readOpenClawBrainProviderConfigFromSources({
+        env: process.env,
+        activationRoot
+    });
+    const warnings = providerConfig.warnings.filter((warning) => /OPENCLAWBRAIN_TEACHER_|provider defaults/u.test(warning));
+    if (providerConfig.teacher.provider !== "ollama") {
+        return {
+            teacherLabeler: null,
+            warnings
+        };
+    }
+    return {
+        teacherLabeler: {
+            provider: "ollama",
+            baseUrl: providerConfig.teacherBaseUrl,
+            model: providerConfig.teacher.model,
+            ...(providerConfig.teacher.timeoutMs === undefined ? {} : { timeoutMs: providerConfig.teacher.timeoutMs }),
+            ...(providerConfig.teacher.maxPromptChars === undefined ? {} : { maxPromptChars: providerConfig.teacher.maxPromptChars }),
+            ...(providerConfig.teacher.maxResponseChars === undefined ? {} : { maxResponseChars: providerConfig.teacher.maxResponseChars }),
+            ...(providerConfig.teacher.maxOutputTokens === undefined ? {} : { maxOutputTokens: providerConfig.teacher.maxOutputTokens }),
+            ...(providerConfig.teacher.maxArtifactsPerExport === undefined
+                ? {}
+                : { maxArtifactsPerExport: providerConfig.teacher.maxArtifactsPerExport }),
+            ...(providerConfig.teacher.maxInteractionsPerExport === undefined
+                ? {}
+                : { maxInteractionsPerExport: providerConfig.teacher.maxInteractionsPerExport })
+        },
+        warnings
+    };
+}
 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 sessionTailCursorPath = resolveWatchSessionTailCursorPath(activationRoot);
     const teacherSnapshotPath = resolveWatchTeacherSnapshotPath(activationRoot);
+    const restoredTeacherState = loadWatchTeacherSnapshotState(teacherSnapshotPath);
     const log = input.log ?? watchLog;
+    const startupWarnings = [];
     mkdirSync(scanRoot, { recursive: true });
     mkdirSync(resolveWatchStateRoot(activationRoot), { recursive: true });
     log(`Watch starting — activation: ${shortenPath(activationRoot)}`);
     log(`Scan root: ${shortenPath(scanRoot)}`);
     log(`State: cursor=${shortenPath(sessionTailCursorPath)} snapshot=${shortenPath(teacherSnapshotPath)}`);
+    const resolvedTeacherLabeler = resolveWatchTeacherLabelerConfig(input.teacherLabeler, activationRoot);
+    const teacherLabeler = resolvedTeacherLabeler.teacherLabeler;
+    for (const warning of resolvedTeacherLabeler.warnings) {
+        startupWarnings.push(`teacher_config_warning:${warning}`);
+        log(`Teacher config warning: ${warning}`);
+    }
+    if (teacherLabeler?.provider === "ollama") {
+        log(`Teacher labeler: provider=ollama model=${teacherLabeler.model ?? "qwen3.5:9b"}`);
+    }
     const scanner = createRuntimeEventExportScanner({ scanRoot });
     let lastServeTimeFallbackReason = null;
-    const teacherLoop = createAsyncTeacherLiveLoop({
+    const baseTeacherLoopInput = {
         packLabel: "watch-cli",
         workspace: {
             workspaceId: "watch-cli",
@@ -2603,6 +3606,7 @@ export async function createWatchCommandRuntime(input) {
             revision: "watch-cli-v2"
         },
         learnedRouting: true,
+        ...(teacherLabeler !== null ? { teacherLabeler } : {}),
         resolveLearnedRoutingState: () => {
             const resolved = resolveServeTimeLearningRuntimeInput(activationRoot);
             if (resolved.fallbackReason !== null && resolved.fallbackReason !== lastServeTimeFallbackReason) {
@@ -2620,11 +3624,38 @@ export async function createWatchCommandRuntime(input) {
                 persistBaseline(activationRoot, state);
             }
             catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                log(`Baseline persist failed: ${message}`);
+                log(`Baseline persist failed: ${formatWatchError(error)}`);
             }
         }
-    });
+    };
+    let teacherLoop;
+    let lastHandledMaterializationPackId = restoredTeacherState.lastHandledMaterializationPackId;
+    if (restoredTeacherState.error !== null) {
+        const message = restoredTeacherState.error;
+        startupWarnings.push(`teacher_snapshot_reset:${message}`);
+        lastHandledMaterializationPackId = null;
+        log(`Teacher snapshot reset: ${message}`);
+        teacherLoop = createAsyncTeacherLiveLoop(baseTeacherLoopInput);
+    }
+    else {
+        try {
+            teacherLoop = createAsyncTeacherLiveLoop({
+                ...baseTeacherLoopInput,
+                ...(restoredTeacherState.snapshot !== null ? { resumeFromSnapshot: restoredTeacherState.snapshot } : {})
+            });
+        }
+        catch (error) {
+            const message = formatWatchError(error);
+            startupWarnings.push(`teacher_snapshot_reset:${message}`);
+            lastHandledMaterializationPackId = null;
+            log(`Teacher snapshot reset: ${message}`);
+            teacherLoop = createAsyncTeacherLiveLoop(baseTeacherLoopInput);
+        }
+    }
+    if (restoredTeacherState.snapshot !== null && startupWarnings.length === 0) {
+        const restoredSeenExportCount = restoredTeacherState.snapshot.state?.seenExportDigests.length ?? 0;
+        log(`Restored teacher snapshot: seen=${restoredSeenExportCount} artifacts=${restoredTeacherState.snapshot.teacher.artifactCount}`);
+    }
     let restoredCursor = loadWatchSessionTailCursor(sessionTailCursorPath);
     let localSessionTail;
     try {
@@ -2644,8 +3675,18 @@ export async function createWatchCommandRuntime(input) {
         });
         persistWatchSessionTailCursor(sessionTailCursorPath, []);
     }
-    let lastHandledMaterializationPackId = loadWatchTeacherSnapshotState(teacherSnapshotPath).lastHandledMaterializationPackId;
-    const replayState = await replayWatchScanRootIntoTeacherLoop(teacherLoop, scanRoot);
+    let replayState = {
+        replayedBundleCount: 0,
+        replayedEventCount: 0
+    };
+    try {
+        replayState = await replayWatchScanRootIntoTeacherLoop(teacherLoop, scanRoot);
+    }
+    catch (error) {
+        const message = formatWatchError(error);
+        startupWarnings.push(`teacher_replay_failed:${message}`);
+        log(`Async teacher replay fail-open: ${message}`);
+    }
     if (replayState.replayedBundleCount > 0) {
         log(`Replayed ${replayState.replayedBundleCount} stored export bundle${replayState.replayedBundleCount === 1 ? "" : "s"} (${replayState.replayedEventCount} event${replayState.replayedEventCount === 1 ? "" : "s"})`);
     }
@@ -2656,14 +3697,25 @@ export async function createWatchCommandRuntime(input) {
         log(replayPromotion.logLine);
         bootstrapSnapshot = teacherLoop.snapshot();
     }
+    const bootstrapCursor = localSessionTail.snapshot();
     persistWatchTeacherSnapshot(teacherSnapshotPath, {
+        lastRunAt: bootstrapObservedAt,
         scanRoot,
+        sessionTailCursorPath,
+        sessionTailCursorUpdatedAt: bootstrapObservedAt,
+        sessionTailSessionsTracked: bootstrapCursor.length,
+        sessionTailBridgedEventCount: countWatchCursorBridgedEvents(bootstrapCursor),
+        scannerCheckpointPath: scanner.checkpointPath,
+        scannerCheckpoint: scanner.snapshot(),
         replayedBundleCount: replayState.replayedBundleCount,
         replayedEventCount: replayState.replayedEventCount,
         exportedBundleCount: 0,
         exportedEventCount: 0,
+        startupWarnings,
+        lastTeacherError: null,
         localSessionTailNoopReason: null,
         lastHandledMaterializationPackId,
+        failure: replayPromotion.failure,
         snapshot: bootstrapSnapshot
     });
     return {
@@ -2671,6 +3723,8 @@ export async function createWatchCommandRuntime(input) {
         scanRoot,
         sessionTailCursorPath,
         teacherSnapshotPath,
+        startupWarnings,
+        lastTeacherError: null,
         replayState,
         lastHandledMaterializationPackId,
         scanner,
@@ -2684,6 +3738,7 @@ export async function runWatchCommandPass(runtime, options = {}) {
     const localPoll = runtime.localSessionTail.pollOnce({
         observedAt
     });
+    const scannerCheckpointBeforeScan = runtime.scanner.snapshot();
     const exported = exportLocalSessionTailChangesToScanRoot({
         scanRoot: runtime.scanRoot,
         polledAt: localPoll.polledAt,
@@ -2703,31 +3758,71 @@ export async function runWatchCommandPass(runtime, options = {}) {
     const totalEvents = scanResult.selected.reduce((sum, hit) => sum + hit.eventRange.count, 0);
     let snapshot = runtime.teacherLoop.snapshot();
     let materializedPackId = null;
+    let failure = null;
     if (totalSelected === 0) {
         log("Scanning... no changes");
     }
     else {
         log(`Scanning... ${totalSelected} export bundle${totalSelected === 1 ? "" : "s"} selected, ${totalEvents} event${totalEvents === 1 ? "" : "s"}`);
-        const ingestResult = await runtime.teacherLoop.ingestRuntimeEventExportScannerScan(scanResult);
-        snapshot = ingestResult.snapshot;
-        const promotion = applyWatchMaterialization(runtime.activationRoot, snapshot, runtime.lastHandledMaterializationPackId);
-        runtime.lastHandledMaterializationPackId = promotion.lastHandledMaterializationPackId;
-        materializedPackId = promotion.materializedPackId;
-        if (promotion.logLine !== null) {
-            log(promotion.logLine);
+        try {
+            const ingestResult = await runtime.teacherLoop.ingestRuntimeEventExportScannerScan(scanResult);
+            runtime.lastTeacherError = null;
+            snapshot = ingestResult.snapshot;
+            const promotion = applyWatchMaterialization(runtime.activationRoot, snapshot, runtime.lastHandledMaterializationPackId);
+            runtime.lastHandledMaterializationPackId = promotion.lastHandledMaterializationPackId;
+            materializedPackId = promotion.materializedPackId;
+            failure = promotion.failure;
+            if (promotion.logLine !== null) {
+                log(promotion.logLine);
+                snapshot = runtime.teacherLoop.snapshot();
+            }
+        }
+        catch (error) {
+            const message = formatWatchError(error);
+            runtime.lastTeacherError = message;
+            failure = {
+                mode: "teacher_fail_open",
+                detail: message,
+                at: observedAt
+            };
+            log(`Async teacher fail-open: ${message}`);
+            try {
+                runtime.scanner.restoreCheckpoint(scannerCheckpointBeforeScan);
+            }
+            catch (restoreError) {
+                const restoreMessage = formatWatchError(restoreError);
+                runtime.lastTeacherError = `${message}; scanner checkpoint restore failed: ${restoreMessage}`;
+                failure = {
+                    mode: "teacher_fail_open",
+                    detail: runtime.lastTeacherError,
+                    at: observedAt
+                };
+                log(`Scanner checkpoint restore failed: ${restoreMessage}`);
+            }
             snapshot = runtime.teacherLoop.snapshot();
         }
     }
     persistWatchTeacherSnapshot(runtime.teacherSnapshotPath, {
+        lastRunAt: observedAt,
         scanRoot: runtime.scanRoot,
+        sessionTailCursorPath: runtime.sessionTailCursorPath,
+        sessionTailCursorUpdatedAt: observedAt,
+        sessionTailSessionsTracked: localPoll.cursor.length,
+        sessionTailBridgedEventCount: countWatchCursorBridgedEvents(localPoll.cursor),
+        scannerCheckpointPath: runtime.scanner.checkpointPath,
+        scannerCheckpoint: runtime.scanner.snapshot(),
         replayedBundleCount: runtime.replayState.replayedBundleCount,
         replayedEventCount: runtime.replayState.replayedEventCount,
         exportedBundleCount: exported.exportedBundleCount,
         exportedEventCount: exported.exportedEventCount,
+        startupWarnings: runtime.startupWarnings,
+        lastTeacherError: runtime.lastTeacherError,
         localSessionTailNoopReason: localPoll.noopReason,
         lastHandledMaterializationPackId: runtime.lastHandledMaterializationPackId,
+        failure,
         snapshot
     });
+    const persistedScannerCheckpoint = runtime.scanner.snapshot();
     if (options.json) {
         console.log(JSON.stringify({
             timestamp: observedAt,
@@ -2739,6 +3834,10 @@ export async function runWatchCommandPass(runtime, options = {}) {
             events: totalEvents,
             live: scanResult.live.length,
             backfill: scanResult.backfill.length,
+            sessionTailSessionsTracked: localPoll.cursor.length,
+            sessionTailBridgedEvents: countWatchCursorBridgedEvents(localPoll.cursor),
+            scannerProcessedBundles: persistedScannerCheckpoint.processedExportDigests.length,
+            scannerLiveAfter: persistedScannerCheckpoint.live.after?.exportDigest ?? null,
             materialized: materializedPackId,
             diagnostics: snapshot.diagnostics ?? null,
             localSessionTailNoopReason: localPoll.noopReason
@@ -2842,12 +3941,13 @@ function resetActivationRoot(activationRoot) {
 function runResetCommand(parsed) {
     if (parsed.help) {
         console.log([
-            "Usage: openclawbrain reset [--activation-root <path>] [--yes] [--json]",
+            "Usage: openclawbrain reset [--activation-root <path>|--openclaw-home <path>] [--yes] [--json]",
             "",
             "Wipes all learned state and returns the brain to seed state.",
             "",
             "Options:",
             "  --activation-root <path>  Activation root (auto-detected if omitted)",
+            "  --openclaw-home <path>   Pin auto-detection to one installed OpenClaw profile",
             "  --yes, -y                 Skip confirmation prompt",
             "  --json                    Emit machine-readable JSON output",
             "  --help                    Show this help"
@@ -2898,7 +3998,7 @@ function runResetCommand(parsed) {
         }
         console.log("  Activation pointers reset to seed state.");
         console.log(`\nBrain at ${shortenPath(activationRoot)} is now in seed state.`);
-        console.log("Run `openclawbrain status` to verify.");
+        console.log(`Run \`openclawbrain status --activation-root ${quoteShellArg(activationRoot)}\` to verify.`);
     }
     return 0;
 }
@@ -2973,8 +4073,8 @@ export function runOperatorCli(argv = process.argv.slice(2)) {
         });
         return 0;
     }
-    if (parsed.command === "install" || parsed.command === "setup") {
-        return runSetupCommand(parsed);
+    if (parsed.command === "install") {
+        return runInstallCommand(parsed);
     }
     if (parsed.command === "detach") {
         return runDetachCommand(parsed);
@@ -2983,31 +4083,7 @@ export function runOperatorCli(argv = process.argv.slice(2)) {
         return runUninstallCommand(parsed);
     }
     if (parsed.command === "attach") {
-        mkdirSync(parsed.activationRoot, { recursive: true });
-        mkdirSync(parsed.packRoot, { recursive: true });
-        const result = bootstrapRuntimeAttach({
-            profileSelector: "current_profile",
-            ...(parsed.brainAttachmentPolicy != null ? { brainAttachmentPolicy: parsed.brainAttachmentPolicy } : {}),
-            activationRoot: parsed.activationRoot,
-            packRoot: parsed.packRoot,
-            packLabel: parsed.packLabel,
-            workspace: {
-                workspaceId: parsed.workspaceId,
-                snapshotId: `${parsed.workspaceId}@bootstrap-${new Date().toISOString().slice(0, 10)}`,
-                capturedAt: new Date().toISOString(),
-                rootDir: process.cwd(),
-                revision: "cli-bootstrap-v1"
-            },
-            interactionEvents: [],
-            feedbackEvents: []
-        });
-        if (parsed.json) {
-            console.log(JSON.stringify(result, null, 2));
-        }
-        else {
-            console.log(formatBootstrapRuntimeAttachReport(result));
-        }
-        return 0;
+        return runAttachCommand(parsed);
     }
     if (parsed.command === "scan") {
         if (parsed.sessionPath !== null) {
@@ -3044,7 +4120,8 @@ export function runOperatorCli(argv = process.argv.slice(2)) {
     }
     // At this point only status/rollback commands remain
     const statusOrRollback = parsed;
-    const activationRoot = requireActivationRoot(statusOrRollback.input, statusOrRollback.command);
+    const activationRoot = requireActivationRoot(statusOrRollback.input, statusOrRollback.openclawHome, statusOrRollback.command);
+    const targetInspection = statusOrRollback.openclawHome === null ? null : inspectOpenClawHome(statusOrRollback.openclawHome);
     if (statusOrRollback.command === "rollback") {
         const result = rollbackRuntimeAttach({
             activationRoot,
@@ -3070,11 +4147,18 @@ export function runOperatorCli(argv = process.argv.slice(2)) {
     }
     else {
         const report = buildOperatorSurfaceReport(operatorInput);
+        const providerConfig = readOpenClawBrainProviderConfig(process.env);
         if (statusOrRollback.detailed) {
-            console.log(formatCurrentProfileStatusSummary(status, report));
+            console.log(formatCurrentProfileStatusSummary(status, report, targetInspection, {
+                openclawHome: statusOrRollback.openclawHome,
+                providerConfig
+            }));
         }
         else {
-            console.log(formatHumanFriendlyStatus(status, report));
+            console.log(formatHumanFriendlyStatus(status, report, targetInspection, {
+                openclawHome: statusOrRollback.openclawHome,
+                providerConfig
+            }));
         }
     }
     return 0;