@openclawbrain/openclaw 0.2.2 → 0.3.0

package/dist/src/cli.js

@@ -1,21 +1,170 @@
 #!/usr/bin/env node
-import { execSync } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, readdirSync, readSync, openSync, closeSync, realpathSync, rmSync, statSync, writeFileSync, appendFileSync } from "node:fs";
+import { execFileSync, execSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, readdirSync, readSync, openSync, closeSync, realpathSync, rmSync, statSync, writeFileSync, appendFileSync, 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 { parseDaemonArgs, runDaemonCommand } from "./daemon.js";
 import { exportBrain, importBrain } from "./import-export.js";
-import { advanceAlwaysOnLearningRuntime, createAlwaysOnLearningRuntimeState, materializeAlwaysOnLearningCandidatePack } from "@openclawbrain/learner";
-import { inspectActivationState, promoteCandidatePack, stageCandidatePack, } from "@openclawbrain/pack-format";
+import { buildNormalizedEventExport } from "@openclawbrain/contracts";
+import { buildTeacherSupervisionArtifactsFromNormalizedEventExport, createAlwaysOnLearningRuntimeState, describeAlwaysOnLearningRuntimeState, drainAlwaysOnLearningRuntime, loadOrInitBaseline, materializeAlwaysOnLearningCandidatePack, persistBaseline } from "@openclawbrain/learner";
+import { inspectActivationState, loadPackFromActivation, promoteCandidatePack, readLearningSpineLogEntries, stageCandidatePack } from "@openclawbrain/pack-format";
 import { resolveActivationRoot } from "./resolve-activation-root.js";
-import { bootstrapRuntimeAttach, buildOperatorSurfaceReport, compileRuntimeContext, createAsyncTeacherLiveLoop, createRuntimeEventExportScanner, describeCurrentProfileBrainStatus, formatBootstrapRuntimeAttachReport, formatOperatorRollbackReport, loadRuntimeEventExportBundle, rollbackRuntimeAttach, scanLiveEventExport, scanRecordedSession } from "./index.js";
+import { buildNormalizedEventExportFromScannedEvents, bootstrapRuntimeAttach, buildOperatorSurfaceReport, compileRuntimeContext, createAsyncTeacherLiveLoop, createOpenClawLocalSessionTail, createRuntimeEventExportScanner, describeCurrentProfileBrainStatus, formatBootstrapRuntimeAttachReport, 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 { discoverOpenClawMainSessionStores, loadOpenClawSessionIndex, readOpenClawSessionFile } from "./session-store.js";
+import { discoverOpenClawSessionStores, loadOpenClawSessionIndex, readOpenClawSessionFile } from "./session-store.js";
+import { readOpenClawBrainProviderConfig } from "./provider-config.js";
 function quoteShellArg(value) {
     return `'${value.replace(/'/g, `"'"'`)}'`;
 }
+function normalizeOptionalCliString(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function getCliHomeDir() {
+    return process.env.HOME ?? process.env.USERPROFILE ?? "~";
+}
+function discoverInstallCandidateOpenClawHomes(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 formatInstallOpenClawHomeSource(source) {
+    switch (source) {
+        case "explicit":
+            return "--openclaw-home";
+        case "env":
+            return "OPENCLAW_HOME";
+        case "discovered_single_profile":
+            return "single discovered live profile";
+        default:
+            return source;
+    }
+}
+function resolveInstallOpenClawHome(explicitOpenclawHome) {
+    const normalizedExplicitHome = normalizeOptionalCliString(explicitOpenclawHome);
+    if (normalizedExplicitHome !== null) {
+        return {
+            openclawHome: path.resolve(normalizedExplicitHome),
+            openclawHomeSource: "explicit"
+        };
+    }
+    const envOpenClawHome = normalizeOptionalCliString(process.env.OPENCLAW_HOME);
+    if (envOpenClawHome !== null) {
+        return {
+            openclawHome: path.resolve(envOpenClawHome),
+            openclawHomeSource: "env"
+        };
+    }
+    const discoveredHomes = discoverInstallCandidateOpenClawHomes();
+    if (discoveredHomes.length === 1) {
+        return {
+            openclawHome: path.resolve(discoveredHomes[0]),
+            openclawHomeSource: "discovered_single_profile"
+        };
+    }
+    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)}`;
+        })
+            .join("\n");
+        throw new Error([
+            "Refusing ambiguous live OpenClaw targets for install.",
+            targetChoices,
+            "Pass --openclaw-home <path> or set OPENCLAW_HOME to pin one profile."
+        ].join("\n"));
+    }
+    throw new Error("No OpenClaw profile home found. Pass --openclaw-home <path> or set OPENCLAW_HOME.");
+}
+function resolveInstallActivationRoot(openclawHome, explicitActivationRoot) {
+    const normalizedExplicitActivationRoot = normalizeOptionalCliString(explicitActivationRoot);
+    if (normalizedExplicitActivationRoot !== null) {
+        return {
+            activationRoot: path.resolve(normalizedExplicitActivationRoot),
+            source: "explicit"
+        };
+    }
+    return {
+        activationRoot: path.resolve(path.dirname(openclawHome), ".openclawbrain", "activation"),
+        source: "default_from_openclaw_home"
+    };
+}
+function resolveInstallWorkspaceId(openclawHome, explicitWorkspaceId) {
+    const normalizedExplicitWorkspaceId = normalizeOptionalCliString(explicitWorkspaceId);
+    if (normalizedExplicitWorkspaceId !== null) {
+        return {
+            workspaceId: normalizedExplicitWorkspaceId,
+            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"
+            };
+        }
+    }
+    catch {
+        // Fall back to the profile-home name when install is pointed at an incomplete or not-yet-readable profile.
+    }
+    const dirName = path.basename(openclawHome);
+    if (dirName === ".openclaw") {
+        return {
+            workspaceId: "default",
+            source: "openclaw_home_dir"
+        };
+    }
+    const derivedWorkspaceId = dirName.startsWith(".openclaw-") ? dirName.slice(".openclaw-".length) : dirName;
+    if (derivedWorkspaceId.trim().length > 0) {
+        return {
+            workspaceId: derivedWorkspaceId,
+            source: "openclaw_home_dir"
+        };
+    }
+    return {
+        workspaceId: "workspace",
+        source: "fallback"
+    };
+}
+function formatInstallActivationRootSource(source) {
+    if (source === "explicit") {
+        return "explicit --activation-root";
+    }
+    return "default beside --openclaw-home";
+}
+function formatInstallWorkspaceIdSource(source) {
+    switch (source) {
+        case "explicit":
+            return "explicit --workspace-id";
+        case "openclaw_json_profile":
+            return "from openclaw.json profile";
+        case "openclaw_home_dir":
+            return "from OpenClaw home dir";
+        default:
+            return "fallback default";
+    }
+}
 function detectConsumerSafeOperatorCliPrefix() {
     const npmExecPath = (process.env.npm_execpath ?? "").toLowerCase();
     const userAgent = process.env.npm_config_user_agent ?? "";
@@ -115,7 +264,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) {
@@ -129,30 +278,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 setup --openclaw-home <path> [options]",
+        "  openclawbrain install [--openclaw-home <path>] [options]",
+        "  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 <status|rollback> [--activation-root <path>|--openclaw-home <path>] [options]",
+        "  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 watch --activation-root <path> [--scan-root <path>] [--interval <seconds>]",
+        "  openclawbrain daemon <start|stop|status|logs> --activation-root <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 setup (e.g. ~/.openclaw-Tern).",
-        "  --shared                    Set brain-attachment-policy to shared instead of dedicated (setup only).",
-        "  --activation-root <path>    Activation root to bootstrap or inspect.",
+        "  --openclaw-home <path>      OpenClaw profile home dir for install/detach/uninstall (e.g. ~/.openclaw-Tern). Also pins status/rollback/context/history/learn to that installed profile when applicable.",
+        "  --shared                    Set brain-attachment-policy to shared instead of dedicated (install only).",
+        "  --activation-root <path>    Explicit activation root for attach/watch/daemon and other stateful commands; install defaults 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 provenance (attach only; defaults to 'workspace').",
+        "  --workspace-id <id>         Workspace identifier for attach/install provenance; install defaults to openclaw.json.profile or the profile name, attach defaults to 'workspace'.",
         "  --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).",
@@ -171,19 +332,26 @@ function operatorCliHelp() {
         "  --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",
+        "  1. status          openclawbrain status --activation-root <path> — answer \"How's the brain?\" for that boundary",
+        "  2. status --json   openclawbrain status --activation-root <path> --json — read the canonical current_profile_brain_status.v1 object",
+        "  3. rollback --dry-run   openclawbrain rollback --activation-root <path> --dry-run — preview active <- previous, active -> candidate",
+        "  4. rollback             openclawbrain rollback --activation-root <path> — 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",
         "  status --teacher-snapshot keeps the current live-first / principal-priority / passive-backfill learner order visible when that snapshot exists",
+        "  watch/daemon persist their operator snapshot at <activation-root>/watch/teacher-snapshot.json; --teacher-snapshot overrides the default path",
+        "  watch Ollama teacher labels: set OPENCLAWBRAIN_TEACHER_PROVIDER=ollama plus optional OPENCLAWBRAIN_TEACHER_BASE_URL, OPENCLAWBRAIN_TEACHER_MODEL, and OPENCLAWBRAIN_TEACHER_* budget vars",
         "",
         "Exit codes:",
         "  status: 0 on successful inspection, 1 on input/read failure.",
         "  rollback: 0 when ready/applied, 1 when blocked or 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."
     ].join("\n");
 }
@@ -225,6 +393,12 @@ function formatLearningBuckets(report) {
 function formatLearningWarnings(report) {
     return report.learning.warningStates.length === 0 ? "none" : report.learning.warningStates.join("|");
 }
+function formatLabelFlowSummary(labelFlow) {
+    return `source=${labelFlow.source} human=${labelFlow.humanLabelCount ?? "none"} self=${labelFlow.selfLabelCount ?? "none"} implicitPositive=${labelFlow.implicitPositiveCount ?? "none"} teacherArtifacts=${labelFlow.asyncTeacherArtifactCount ?? "none"}`;
+}
+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) {
     const profileIdSuffix = status.profile.profileId === null ? "" : ` id=${status.profile.profileId}`;
     return [
@@ -233,6 +407,7 @@ function formatCurrentProfileStatusSummary(status, report) {
         `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"}`,
@@ -240,8 +415,12 @@ function formatCurrentProfileStatusSummary(status, report) {
         `decision    ${status.brainStatus.structuralDecision.detail}`,
         `principal   latest=${formatPrincipalLatest(report)} pending=${report.principal.pendingCount ?? report.learning.pendingPrincipalCount ?? "none"} checkpoint=${formatPrincipalCheckpointFrontier(report)} downstream=${yesNo(report.principal.servingDownstreamOfLatestCorrection)} lag=${report.learning.principalLagToPromotion.sequenceLag ?? "none"}`,
         `scanner     flowing=${yesNo(report.supervision.flowing)} scan=${report.supervision.scanPolicy ?? "none"} surfaces=${formatScannerSurfaces(report)} labels=${report.supervision.humanLabelCount ?? "none"}/${report.supervision.selfLabelCount ?? "none"} attributable=${report.supervision.attributedEventCount ?? "none"}/${report.supervision.totalEventCount ?? "none"} digests=${report.supervision.selectionDigestCount ?? "none"}`,
+        `labels      ${formatLabelFlowSummary(report.labelFlow)}`,
         `graph       source=${report.graph.runtimePlasticitySource ?? "none"} ops=${formatStructuralOps(report)} changed=${yesNo(report.graph.changed)} pruned=${report.graph.prunedBlockCount ?? "none"} strongest=${report.graph.strongestBlockId ?? "none"} summary=${report.graph.operatorSummary ?? report.graph.detail}`,
+        `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"} 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)} noOp=${report.teacherLoop.lastNoOpReason} failure=${report.teacherLoop.failureMode}${report.teacherLoop.failureDetail === null ? "" : `(${report.teacherLoop.failureDetail})`}`,
+        `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"}`,
@@ -258,6 +437,47 @@ function shortenPath(fullPath) {
     }
     return fullPath;
 }
+function buildInstallStatusCommand(activationRoot) {
+    return `openclawbrain status --activation-root ${quoteShellArg(activationRoot)}`;
+}
+function buildInstallCommand(openclawHome) {
+    return `openclawbrain install --openclaw-home ${quoteShellArg(openclawHome)}`;
+}
+function buildInstallReloadGuidance() {
+    return "If this OpenClaw profile is currently running, restart it before expecting the new brain hook to load. If it is stopped, the next launch will pick it up.";
+}
+function 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.";
+    }
+    if (restart === "external") {
+        return "Restart this OpenClaw profile externally if it is currently running. If it is stopped, the next launch will pick up the new hook state.";
+    }
+    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 --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 --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 --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) {
     // Brain status line
     const brainActive = status.brainStatus.status === "ok" || status.brainStatus.serveState === "serving_active_pack";
@@ -270,11 +490,22 @@ function formatHumanFriendlyStatus(status, report) {
     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";
     const lines = [
         `Brain: ${brainIcon}`,
         `Pack:  ${packShort} (${state})`,
         `Activation: ${activationPath}`,
-        `Policy: ${policy}`
+        `Policy: ${policy}`,
+        `Lifecycle: activation=${status.brainStatus.activationState} 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)}`,
+        `Teacher: lastRun=${report.teacherLoop.lastRunAt ?? "none"} artifacts=${report.teacherLoop.artifactCount ?? "none"} exported=${report.teacherLoop.exportedBundleCount ?? "none"}/${report.teacherLoop.exportedEventCount ?? "none"} cadence=${report.teacherLoop.learningCadence}/${report.teacherLoop.scanPolicy} failure=${report.teacherLoop.failureMode}`,
+        `Learning: ${formatLearningPathSummary(report.learningPath)}`
     ];
     // Add learning/serve warnings if relevant
     if (report.learning.warningStates.length > 0) {
@@ -283,13 +514,25 @@ function formatHumanFriendlyStatus(status, report) {
     if (status.brainStatus.awaitingFirstExport) {
         lines.push(`Note: Awaiting first event export`);
     }
+    lines.push(`Next: ${buildStatusNextStep(status, report)}`);
     return lines.join("\n");
 }
-function requireActivationRoot(input, _command) {
-    // Use the shared auto-detect chain for ALL commands:
-    //   explicit flag → ~/.openclawbrain/activation → extension scan → clear error
+function requireActivationRoot(input, openclawHome, command) {
+    const explicitActivationRoot = input.activationRoot.trim().length > 0 ? input.activationRoot : null;
+    if (explicitActivationRoot !== null) {
+        return path.resolve(explicitActivationRoot);
+    }
+    if (openclawHome !== null) {
+        return resolveActivationRoot({
+            openclawHome
+        });
+    }
+    throw new Error(`${command} requires --activation-root <path> or --openclaw-home <path>; unpinned host auto-resolution is no longer supported for ${command}.`);
+}
+function resolveCliActivationRoot(explicitActivationRoot, openclawHome) {
     return resolveActivationRoot({
-        explicit: input.activationRoot.trim().length > 0 ? input.activationRoot : null,
+        explicit: explicitActivationRoot,
+        openclawHome
     });
 }
 function readJsonFile(filePath) {
@@ -321,6 +564,8 @@ function formatScanLiveSummary(result, snapshotOutPath) {
         "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}`,
+        `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}`,
         `observed    ${result.observedAt}`,
         `snapshot    ${snapshotOutPath ?? "none"}`
@@ -344,6 +589,10 @@ export function parseOperatorCliArgs(argv) {
     let snapshotOutPath = null;
     let openclawHome = null;
     let shared = false;
+    let keepData = false;
+    let purgeData = false;
+    let restart = "safe";
+    let restartExplicitlySet = false;
     let json = false;
     let help = false;
     let dryRun = false;
@@ -352,11 +601,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] === "setup" || 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") {
@@ -379,6 +631,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}`);
             }
@@ -388,7 +649,7 @@ export function parseOperatorCliArgs(argv) {
         }
         return {
             command,
-            activationRoot: resolveActivationRoot({ explicit: activationRoot }),
+            activationRoot: resolveCliActivationRoot(activationRoot, openclawHome),
             json,
             help
         };
@@ -444,9 +705,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,
@@ -474,6 +738,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}`);
             }
@@ -488,7 +761,7 @@ export function parseOperatorCliArgs(argv) {
         return {
             command,
             message: messageParts.join(" "),
-            activationRoot: resolveActivationRoot({ explicit: activationRoot }),
+            activationRoot: resolveCliActivationRoot(activationRoot, openclawHome),
             json,
             help
         };
@@ -514,6 +787,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) {
@@ -536,7 +818,7 @@ export function parseOperatorCliArgs(argv) {
         }
         return {
             command,
-            activationRoot: resolveActivationRoot({ explicit: activationRoot }),
+            activationRoot: resolveCliActivationRoot(activationRoot, openclawHome),
             limit: historyLimit,
             json,
             help
@@ -562,6 +844,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)
@@ -579,7 +869,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,
@@ -610,6 +900,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) {
@@ -626,7 +924,7 @@ export function parseOperatorCliArgs(argv) {
         return {
             command,
             archivePath: path.resolve(archivePath),
-            activationRoot: resolveActivationRoot({ explicit: activationRoot }),
+            activationRoot: resolveCliActivationRoot(activationRoot, openclawHome),
             force,
             json,
             help,
@@ -656,13 +954,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
@@ -686,6 +992,27 @@ export function parseOperatorCliArgs(argv) {
             shared = true;
             continue;
         }
+        if (arg === "--keep-data") {
+            keepData = true;
+            continue;
+        }
+        if (arg === "--purge-data") {
+            purgeData = true;
+            continue;
+        }
+        if (arg === "--restart") {
+            const next = args[index + 1];
+            if (next === undefined) {
+                throw new Error("--restart requires a value");
+            }
+            if (next !== "never" && next !== "safe" && next !== "external") {
+                throw new Error(`invalid --restart value: ${next}`);
+            }
+            restart = next;
+            restartExplicitlySet = true;
+            index += 1;
+            continue;
+        }
         if (arg === "--detailed") {
             detailed = true;
             continue;
@@ -816,25 +1143,99 @@ export function parseOperatorCliArgs(argv) {
         }
         throw new Error(`unknown argument: ${arg}`);
     }
-    if (command === "setup") {
+    if (command !== "detach" && command !== "uninstall" && restartExplicitlySet) {
+        throw new Error("--restart only applies to detach/uninstall");
+    }
+    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") {
+        if (help) {
+            return {
+                command,
+                openclawHome: "",
+                openclawHomeSource: "explicit",
+                activationRoot: "",
+                activationRootSource: "explicit",
+                shared: false,
+                workspaceId: "",
+                workspaceIdSource: "explicit",
+                json,
+                help
+            };
+        }
+        const resolvedOpenclawHome = resolveInstallOpenClawHome(openclawHome);
+        const resolvedActivationRoot = resolveInstallActivationRoot(resolvedOpenclawHome.openclawHome, activationRoot);
+        const resolvedWorkspaceId = resolveInstallWorkspaceId(resolvedOpenclawHome.openclawHome, workspaceId);
+        return {
+            command,
+            openclawHome: resolvedOpenclawHome.openclawHome,
+            openclawHomeSource: resolvedOpenclawHome.openclawHomeSource,
+            activationRoot: resolvedActivationRoot.activationRoot,
+            activationRootSource: resolvedActivationRoot.source,
+            shared,
+            workspaceId: resolvedWorkspaceId.workspaceId,
+            workspaceIdSource: resolvedWorkspaceId.source,
+            json,
+            help
+        };
+    }
+    if (command === "detach") {
         if (help) {
-            return { command, openclawHome: "", activationRoot: "", shared: false, workspaceId: "", json, help };
+            return { command, openclawHome: "", activationRoot: null, restart: "safe", json, help };
         }
         if (openclawHome === null || openclawHome.trim().length === 0) {
-            throw new Error("--openclaw-home is required for setup");
+            throw new Error("--openclaw-home is required for detach");
+        }
+        if (purgeData) {
+            throw new Error("detach always preserves activation data; use uninstall --purge-data to remove it");
         }
         const resolvedOpenclawHome = path.resolve(openclawHome);
-        const defaultActivationRoot = path.resolve(process.env.HOME ?? "~", ".openclawbrain", "activation");
-        const resolvedActivationRoot = activationRoot !== null ? path.resolve(activationRoot) : defaultActivationRoot;
-        const dirName = path.basename(resolvedOpenclawHome);
-        const derivedWorkspaceId = dirName.startsWith(".openclaw-") ? dirName.slice(".openclaw-".length) : dirName;
-        const resolvedWorkspaceId = workspaceId ?? derivedWorkspaceId;
+        const resolvedActivationRoot = resolveActivationRoot({
+            explicit: activationRoot,
+            openclawHome: resolvedOpenclawHome,
+            quiet: true
+        });
         return {
             command,
             openclawHome: resolvedOpenclawHome,
-            activationRoot: resolvedActivationRoot,
-            shared,
-            workspaceId: resolvedWorkspaceId,
+            activationRoot: resolvedActivationRoot.trim().length === 0 ? null : path.resolve(resolvedActivationRoot),
+            restart,
+            json,
+            help
+        };
+    }
+    if (command === "uninstall") {
+        if (help) {
+            return { command, openclawHome: "", activationRoot: null, dataMode: "keep", restart: "safe", json, help };
+        }
+        if (openclawHome === null || openclawHome.trim().length === 0) {
+            throw new Error("--openclaw-home is required for uninstall");
+        }
+        if (!keepData && !purgeData) {
+            throw new Error("uninstall requires exactly one of --keep-data or --purge-data");
+        }
+        if (keepData && purgeData) {
+            throw new Error("--keep-data and --purge-data are mutually exclusive");
+        }
+        const resolvedOpenclawHome = path.resolve(openclawHome);
+        const resolvedActivationRoot = resolveActivationRoot({
+            explicit: activationRoot,
+            openclawHome: resolvedOpenclawHome,
+            quiet: true
+        });
+        if (purgeData && resolvedActivationRoot.trim().length === 0) {
+            throw new Error("--purge-data requires a resolvable activation root from the installed profile hook or --activation-root <path>");
+        }
+        return {
+            command,
+            openclawHome: resolvedOpenclawHome,
+            activationRoot: resolvedActivationRoot.trim().length === 0 ? null : path.resolve(resolvedActivationRoot),
+            dataMode: purgeData ? "purge" : "keep",
+            restart,
             json,
             help
         };
@@ -905,6 +1306,7 @@ export function parseOperatorCliArgs(argv) {
             updatedAt,
             brainAttachmentPolicy
         },
+        openclawHome: normalizeOptionalCliString(openclawHome),
         json,
         help,
         dryRun,
@@ -939,28 +1341,162 @@ function resolveExtensionTemplatePath() {
     throw new Error("Pre-built extension template not found. Searched:\n" +
         candidates.map((c) => `  - ${c}`).join("\n"));
 }
+function resolveExtensionRuntimeGuardPath() {
+    const tsCandidates = [
+        path.resolve(__dirname, "..", "extension", "runtime-guard.ts"),
+        path.resolve(__dirname, "..", "..", "extension", "runtime-guard.ts"),
+    ];
+    const jsCandidates = [
+        path.resolve(__dirname, "extension", "runtime-guard.js"),
+        path.resolve(__dirname, "..", "extension", "runtime-guard.js"),
+    ];
+    const tsPath = tsCandidates.find((c) => existsSync(c)) ?? null;
+    const jsPath = jsCandidates.find((c) => existsSync(c));
+    if (!jsPath) {
+        throw new Error("Pre-built extension runtime-guard.js not found. Searched:\n" +
+            jsCandidates.map((c) => `  - ${c}`).join("\n"));
+    }
+    return { ts: tsPath, js: jsPath };
+}
+const LOCAL_WORKSPACE_EXTENSION_PACKAGES = [
+    "activation",
+    "compiler",
+    "contracts",
+    "event-export",
+    "events",
+    "learner",
+    "openclaw",
+    "pack-format",
+    "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, "..", "..", "..", ".."),
+        path.resolve(__dirname, "..", "..", "..")
+    ];
+    for (const candidate of candidates) {
+        const packageRoot = path.join(candidate, "packages", "openclaw");
+        const distEntry = path.join(packageRoot, "dist", "src", "index.js");
+        if (existsSync(packageRoot) && existsSync(distEntry)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function installExtensionFromLocalWorkspaceBuild(extensionDir) {
+    const workspaceRoot = resolveLocalWorkspaceRootForExtensionInstall();
+    if (workspaceRoot === null) {
+        return null;
+    }
+    const nodeModulesRoot = path.join(extensionDir, "node_modules", "@openclawbrain");
+    mkdirSync(nodeModulesRoot, { recursive: true });
+    for (const packageName of LOCAL_WORKSPACE_EXTENSION_PACKAGES) {
+        const packageDir = path.join(workspaceRoot, "packages", packageName);
+        const packageDistEntry = path.join(packageDir, "dist", "src", "index.js");
+        if (!existsSync(packageDir) || !existsSync(packageDistEntry)) {
+            return null;
+        }
+    }
+    for (const packageName of LOCAL_WORKSPACE_EXTENSION_PACKAGES) {
+        const packageDir = path.join(workspaceRoot, "packages", packageName);
+        const linkPath = path.join(nodeModulesRoot, packageName);
+        rmSync(linkPath, { recursive: true, force: true });
+        symlinkSync(packageDir, linkPath, "dir");
+    }
+    return [...LOCAL_WORKSPACE_EXTENSION_PACKAGES];
+}
+let cachedOpenClawPackageMetadata = null;
+function resolveOpenClawPackageManifestPath() {
+    const candidates = [
+        path.resolve(__dirname, "..", "package.json"),
+        path.resolve(__dirname, "..", "..", "package.json"),
+    ];
+    for (const candidate of candidates) {
+        if (existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    throw new Error("OpenClawBrain package manifest not found. Searched:\n" +
+        candidates.map((candidate) => `  - ${candidate}`).join("\n"));
+}
+function readOpenClawPackageMetadata() {
+    if (cachedOpenClawPackageMetadata !== null) {
+        return cachedOpenClawPackageMetadata;
+    }
+    const manifestPath = resolveOpenClawPackageManifestPath();
+    const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+    const name = typeof manifest.name === "string" && manifest.name.trim().length > 0
+        ? manifest.name.trim()
+        : "@openclawbrain/openclaw";
+    const version = typeof manifest.version === "string" && manifest.version.trim().length > 0
+        ? manifest.version.trim()
+        : "0.0.0";
+    cachedOpenClawPackageMetadata = { name, version };
+    return cachedOpenClawPackageMetadata;
+}
 function buildExtensionIndexTs(activationRoot) {
     const templatePath = resolveExtensionTemplatePath();
     const template = readFileSync(templatePath, "utf8");
     return template.replace(/const ACTIVATION_ROOT = "__ACTIVATION_ROOT__";/, `const ACTIVATION_ROOT = ${JSON.stringify(activationRoot)};`);
 }
 function buildExtensionPackageJson() {
+    const packageMetadata = readOpenClawPackageMetadata();
     return JSON.stringify({
         name: "openclawbrain-extension",
-        version: "0.1.0",
+        version: packageMetadata.version,
         private: true,
         type: "module",
+        openclaw: {
+            extensions: ["index.ts"]
+        },
         dependencies: {
-            "@openclawbrain/openclaw": ">=0.2.0"
+            [packageMetadata.name]: packageMetadata.version
         }
     }, null, 2) + "\n";
 }
 function buildExtensionPluginManifest() {
+    const packageMetadata = readOpenClawPackageMetadata();
     return JSON.stringify({
         id: "openclawbrain",
         name: "OpenClawBrain",
         description: "Learned memory and context from OpenClawBrain",
-        version: "0.2.0"
+        version: packageMetadata.version,
+        configSchema: {
+            type: "object",
+            additionalProperties: false,
+            properties: {}
+        }
     }, null, 2) + "\n";
 }
 function formatContextForHuman(result) {
@@ -1040,15 +1576,94 @@ 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");
     if (!existsSync(pointersPath)) {
         if (parsed.json) {
-            console.log(JSON.stringify({ entries: [], empty: true, message: "No history yet. Run: openclawbrain setup" }, null, 2));
+            console.log(JSON.stringify({ entries: [], empty: true, message: "No history yet. Run: openclawbrain install" }, null, 2));
         }
         else {
-            console.log("No history yet. Run: openclawbrain setup");
+            console.log("No history yet. Run: openclawbrain install");
         }
         return 0;
     }
@@ -1081,10 +1696,10 @@ function runHistoryCommand(parsed) {
     }
     if (entries.length === 0) {
         if (parsed.json) {
-            console.log(JSON.stringify({ entries: [], empty: true, message: "No history yet. Run: openclawbrain setup" }, null, 2));
+            console.log(JSON.stringify({ entries: [], empty: true, message: "No history yet. Run: openclawbrain install" }, null, 2));
         }
         else {
-            console.log("No history yet. Run: openclawbrain setup");
+            console.log("No history yet. Run: openclawbrain install");
         }
         return 0;
     }
@@ -1121,30 +1736,25 @@ function runHistoryCommand(parsed) {
     }
     return 0;
 }
-function runSetupCommand(parsed) {
+function runInstallCommand(parsed) {
     const steps = [];
+    const commandLabel = parsed.command.toUpperCase();
+    steps.push(`Target OpenClaw profile home: ${parsed.openclawHome} (${formatInstallOpenClawHomeSource(parsed.openclawHomeSource)})`);
     // 1. Validate --openclaw-home exists and has openclaw.json
-    if (!existsSync(parsed.openclawHome)) {
-        throw new Error(`--openclaw-home directory does not exist: ${parsed.openclawHome}`);
-    }
-    const openclawJsonPath = path.join(parsed.openclawHome, "openclaw.json");
-    if (!existsSync(openclawJsonPath)) {
-        throw new Error(`openclaw.json not found in ${parsed.openclawHome}`);
-    }
-    // 2. Create activation root if needed
-    if (!existsSync(parsed.activationRoot)) {
+    validateOpenClawHome(parsed.openclawHome);
+    // 2. Inspect the activation root before writing profile hook artifacts.
+    const activationPlan = inspectInstallActivationPlan(parsed);
+    // 3. 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.");
-    }
-    else {
+    steps.push(activationPlan.inspectionStep);
+    // 4. 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";
@@ -1153,52 +1763,85 @@ function runSetupCommand(parsed) {
             brainAttachmentPolicy,
             activationRoot: parsed.activationRoot,
             packRoot,
-            packLabel: "setup-cli",
+            packLabel: "install-cli",
             workspace: {
                 workspaceId: parsed.workspaceId,
-                snapshotId: `${parsed.workspaceId}@setup-${new Date().toISOString().slice(0, 10)}`,
+                snapshotId: `${parsed.workspaceId}@install-${new Date().toISOString().slice(0, 10)}`,
                 capturedAt: new Date().toISOString(),
                 rootDir: parsed.openclawHome,
-                revision: "cli-setup-v1"
+                revision: "cli-install-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)}`);
+    }
+    else {
+        steps.push(`Kept inspected activation state: active pack ${activationPlan.activePackId}`);
     }
-    // 4-7. Write extension files
+    // 5-8. Write extension files
     const extensionDir = path.join(parsed.openclawHome, "extensions", "openclawbrain");
     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}`);
-    // 5. Write package.json
+    // 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");
+        writeFileSync(runtimeGuardTsPath, readFileSync(runtimeGuardPaths.ts, "utf8"), "utf8");
+        steps.push(`Wrote extension runtime-guard source: ${runtimeGuardTsPath}`);
+    }
+    const runtimeGuardJsPath = path.join(extensionDir, "runtime-guard.js");
+    writeFileSync(runtimeGuardJsPath, readFileSync(runtimeGuardPaths.js, "utf8"), "utf8");
+    steps.push(`Wrote extension runtime-guard: ${runtimeGuardJsPath}`);
+    // 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);
-        steps.push(`npm install failed (non-fatal): ${message}`);
+        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(", ")}`);
+        }
+        else {
+            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
+    // 9. 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`",
+        `- Check: \`openclawbrain status --activation-root ${quoteShellArg(parsed.activationRoot)}\``,
+        `- Rollback: \`openclawbrain rollback --activation-root ${quoteShellArg(parsed.activationRoot)}\``,
         '- See what brain knows: `openclawbrain context "your question"`',
         ""
     ].join("\n");
@@ -1266,58 +1909,361 @@ function runSetupCommand(parsed) {
         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)}`
+    ];
+    const lifecycleSummary = [
+        `OpenClaw profile: ${shortenPath(parsed.openclawHome)} (${formatInstallOpenClawHomeSource(parsed.openclawHomeSource)})`,
+        `Activation root: ${shortenPath(parsed.activationRoot)} (${formatInstallActivationRootSource(parsed.activationRootSource)})`,
+        `Workspace ID: ${parsed.workspaceId} (${formatInstallWorkspaceIdSource(parsed.workspaceIdSource)})`,
+        `Profile hook: installed at ${shortenPath(extensionDir)}`,
+        activationPlan.resolution === "new_root"
+            ? `Activation data: initialized at ${shortenPath(parsed.activationRoot)}`
+            : 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"
+                ? "Brain attach: bootstrapped a seed/current-profile attach"
+                : activationPlan.resolution === "missing_pointers"
+                    ? "Brain attach: repaired missing activation pointers and bootstrapped a seed/current-profile attach"
+                    : "Brain attach: repaired empty activation pointers and bootstrapped a seed/current-profile attach"
+            : `Brain attach: kept healthy active pack ${activationPlan.activePackId} in place`
+    ];
     // 9. Print summary
     if (parsed.json) {
         console.log(JSON.stringify({
-            command: "setup",
+            command: parsed.command,
             openclawHome: parsed.openclawHome,
+            openclawHomeSource: parsed.openclawHomeSource,
             activationRoot: parsed.activationRoot,
+            resolvedInputs: {
+                activationRoot: {
+                    value: parsed.activationRoot,
+                    source: parsed.activationRootSource
+                },
+                workspaceId: {
+                    value: parsed.workspaceId,
+                    source: parsed.workspaceIdSource
+                }
+            },
             workspaceId: parsed.workspaceId,
             shared: parsed.shared,
             extensionDir,
+            lifecycleSummary,
+            restartGuidance,
+            nextSteps,
             steps
         }, null, 2));
     }
     else {
-        console.log("SETUP complete\n");
+        console.log(`${commandLabel} complete\n`);
         for (const step of steps) {
             console.log(`  ✓ ${step}`);
         }
         console.log("");
-        console.log(`Check status:  openclawbrain status --activation-root ${quoteShellArg(parsed.activationRoot)}`);
-        console.log("Next step:     Restart your OpenClaw gateway to activate the extension.");
+        console.log("Lifecycle:");
+        for (const line of lifecycleSummary) {
+            console.log(`  ${line}`);
+        }
+        console.log(`Next:       ${restartGuidance}`);
+        console.log(`Check:      ${buildInstallStatusCommand(parsed.activationRoot)}`);
     }
     return 0;
 }
-function runLearnCommand(parsed) {
-    const activationRoot = parsed.activationRoot;
-    // 1. Discover local session stores
-    const stores = discoverOpenClawMainSessionStores();
-    if (stores.length === 0) {
-        if (parsed.json) {
-            console.log(JSON.stringify({ command: "learn", activationRoot, scannedSessions: 0, newEvents: 0, materialized: null, promoted: false, message: "No local session stores found." }));
-        }
-        else {
-            console.log("No new session data. Brain is up to date.");
-        }
-        return 0;
+function validateOpenClawHome(openclawHome) {
+    if (!existsSync(openclawHome)) {
+        throw new Error(`--openclaw-home directory does not exist: ${openclawHome}`);
     }
-    // 2. Build passive learning export from ALL discovered sessions in one monotonic sequence space
-    let totalSessions = 0;
-    let totalInteractionEvents = 0;
-    let totalFeedbackEvents = 0;
-    const allInteractionEvents = [];
-    const allFeedbackEvents = [];
-    let nextSequence = 1;
-    const discoveredSessions = stores
-        .flatMap((store) => {
-        const sessionIndex = loadOpenClawSessionIndex(store.indexPath);
-        return Object.entries(sessionIndex).map(([sessionKey, entry]) => ({
-            store,
-            sessionKey,
-            entry
-        }));
-    })
+    const openclawJsonPath = path.join(openclawHome, "openclaw.json");
+    if (!existsSync(openclawJsonPath)) {
+        throw new Error(`openclaw.json not found in ${openclawHome}`);
+    }
+}
+function resolveCleanupActivationRoot(openclawHome, explicitActivationRoot) {
+    if (explicitActivationRoot !== null) {
+        return path.resolve(explicitActivationRoot);
+    }
+    const resolved = resolveActivationRoot({
+        openclawHome,
+        quiet: true
+    });
+    return resolved.trim().length === 0 ? null : path.resolve(resolved);
+}
+function removeProfileHookup(openclawHome, steps) {
+    const extensionDir = path.join(openclawHome, "extensions", "openclawbrain");
+    if (!existsSync(extensionDir)) {
+        steps.push(`Profile hookup already absent: ${extensionDir}`);
+        return extensionDir;
+    }
+    rmSync(extensionDir, { recursive: true, force: true });
+    steps.push(`Removed profile hookup: ${extensionDir}`);
+    return extensionDir;
+}
+function summarizeKeptActivationData(activationRoot) {
+    if (activationRoot === null) {
+        return {
+            activationRoot: null,
+            activationDataState: "unresolved",
+            activationDataDetail: "Activation data preserved, but the activation root could not be resolved from the profile hook."
+        };
+    }
+    return {
+        activationRoot,
+        activationDataState: "kept",
+        activationDataDetail: `Activation data preserved at ${activationRoot}`
+    };
+}
+function buildRestartGuidance(restart) {
+    return buildCleanupRestartGuidance(restart);
+}
+function runDetachCommand(parsed) {
+    const steps = [];
+    validateOpenClawHome(parsed.openclawHome);
+    const activationRoot = resolveCleanupActivationRoot(parsed.openclawHome, parsed.activationRoot);
+    const extensionDir = removeProfileHookup(parsed.openclawHome, steps);
+    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)}`
+    ].filter((step) => step !== null);
+    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,
+            extensionDir,
+            activationRoot,
+            dataAction: "kept",
+            activationDataState: activationData.activationDataState,
+            restartMode: parsed.restart,
+            restartGuidance,
+            nextSteps,
+            steps
+        }, null, 2));
+    }
+    else {
+        console.log("DETACH complete\n");
+        for (const step of steps) {
+            console.log(`  ✓ ${step}`);
+        }
+        console.log("");
+        console.log(`Lifecycle:     OpenClaw profile ${shortenPath(parsed.openclawHome)} is detached from the brain hook.`);
+        if (activationRoot !== null) {
+            console.log(`Brain data:    ${shortenPath(activationRoot)} remains available for inspection or reattach.`);
+        }
+        else {
+            console.log("Brain data:    preserved, but the activation root could not be resolved from the removed hook.");
+        }
+        console.log(`Next:          ${restartGuidance}`);
+        if (activationRoot !== null) {
+            console.log(`Check:         ${buildInstallStatusCommand(activationRoot)}`);
+        }
+        console.log(`Reattach:      ${buildInstallCommand(parsed.openclawHome)}`);
+    }
+    return 0;
+}
+function runUninstallCommand(parsed) {
+    const steps = [];
+    validateOpenClawHome(parsed.openclawHome);
+    const activationRoot = resolveCleanupActivationRoot(parsed.openclawHome, parsed.activationRoot);
+    const extensionDir = removeProfileHookup(parsed.openclawHome, steps);
+    let activationData;
+    if (parsed.dataMode === "purge") {
+        if (activationRoot === null) {
+            throw new Error("--purge-data requires a resolvable activation root from the installed profile hook or --activation-root <path>");
+        }
+        if (existsSync(activationRoot)) {
+            rmSync(activationRoot, { recursive: true, force: true });
+            activationData = {
+                activationRoot,
+                activationDataState: "removed",
+                activationDataDetail: `Activation data removed at ${activationRoot}`
+            };
+        }
+        else {
+            activationData = {
+                activationRoot,
+                activationDataState: "already_absent",
+                activationDataDetail: `Activation data already absent at ${activationRoot}`
+            };
+        }
+    }
+    else {
+        activationData = summarizeKeptActivationData(activationRoot);
+    }
+    const restartGuidance = buildRestartGuidance(parsed.restart);
+    const nextSteps = [
+        restartGuidance,
+        parsed.dataMode === "keep" && activationRoot !== null ? `Inspect preserved data: ${buildInstallStatusCommand(activationRoot)}` : null,
+        `Reinstall later: ${buildInstallCommand(parsed.openclawHome)}`
+    ].filter((step) => step !== null);
+    steps.push(activationData.activationDataDetail);
+    steps.push(parsed.dataMode === "purge"
+        ? "Uninstall removed the OpenClaw profile hook and activation data."
+        : "Uninstall removed the OpenClaw profile hook and kept activation data explicitly.");
+    if (parsed.json) {
+        console.log(JSON.stringify({
+            command: "uninstall",
+            openclawHome: parsed.openclawHome,
+            extensionDir,
+            activationRoot,
+            dataAction: parsed.dataMode,
+            activationDataState: activationData.activationDataState,
+            restartMode: parsed.restart,
+            restartGuidance,
+            nextSteps,
+            steps
+        }, null, 2));
+    }
+    else {
+        console.log("UNINSTALL complete\n");
+        for (const step of steps) {
+            console.log(`  ✓ ${step}`);
+        }
+        console.log("");
+        console.log(`Lifecycle:     OpenClaw profile ${shortenPath(parsed.openclawHome)} no longer has the brain hook installed.`);
+        console.log(`Data mode:     ${parsed.dataMode === "purge" ? "purged" : "kept"}`);
+        if (activationRoot !== null) {
+            console.log(`Activation:    ${parsed.dataMode === "purge" ? shortenPath(activationRoot) : `${shortenPath(activationRoot)} preserved`}`);
+        }
+        console.log(`Next:          ${restartGuidance}`);
+        if (parsed.dataMode === "keep" && activationRoot !== null) {
+            console.log(`Check:         ${buildInstallStatusCommand(activationRoot)}`);
+        }
+        console.log(`Reinstall:     ${buildInstallCommand(parsed.openclawHome)}`);
+    }
+    return 0;
+}
+function resolveServeTimeLearningRuntimeInput(activationRoot) {
+    let serveTimeDecisions = [];
+    let fallbackReason = null;
+    try {
+        serveTimeDecisions = readLearningSpineLogEntries(activationRoot, "serveTimeRouteDecisions");
+    }
+    catch {
+        fallbackReason = "serve_time_decision_log_read_failed";
+    }
+    const decisionLogCount = serveTimeDecisions.length;
+    const pgVersion = decisionLogCount > 0 ? "v2" : "v1";
+    return {
+        pgVersion,
+        serveTimeDecisions,
+        decisionLogCount,
+        baselineState: pgVersion === "v2" ? loadOrInitBaseline(activationRoot) : undefined,
+        fallbackReason
+    };
+}
+function runLearnCommand(parsed) {
+    const learnStatePath = path.join(parsed.activationRoot, "learn-cli-state.json");
+    const teacherSnapshotPath = resolveAsyncTeacherLiveLoopSnapshotPath(parsed.activationRoot);
+    function isLearnRuntimeStateLike(value) {
+        if (typeof value !== "object" || value === null) {
+            return false;
+        }
+        const candidate = value;
+        return (candidate.runtimeOwner === "openclaw" &&
+            typeof candidate.cursor === "object" &&
+            candidate.cursor !== null &&
+            typeof candidate.pending === "object" &&
+            candidate.pending !== null &&
+            Array.isArray(candidate.pending.live) &&
+            Array.isArray(candidate.pending.backfill) &&
+            typeof candidate.materializationCount === "number" &&
+            typeof candidate.sparseFeedback === "object" &&
+            candidate.sparseFeedback !== null);
+    }
+    function loadPersistedLearnCliState() {
+        if (!existsSync(learnStatePath)) {
+            return {
+                state: createAlwaysOnLearningRuntimeState(),
+                loaded: false,
+                resetReason: null
+            };
+        }
+        try {
+            const persisted = readJsonFile(learnStatePath);
+            if (persisted.contract !== "openclaw.learn_cli_state.v1" || !isLearnRuntimeStateLike(persisted.state)) {
+                throw new Error("persisted learn state shape is invalid");
+            }
+            return {
+                state: persisted.state,
+                loaded: true,
+                resetReason: null
+            };
+        }
+        catch (error) {
+            return {
+                state: createAlwaysOnLearningRuntimeState(),
+                loaded: false,
+                resetReason: error instanceof Error ? error.message : "persisted learn state could not be parsed"
+            };
+        }
+    }
+    function persistLearnCliState(state, updatedAt) {
+        const payload = {
+            contract: "openclaw.learn_cli_state.v1",
+            updatedAt,
+            state
+        };
+        mkdirSync(path.dirname(learnStatePath), { recursive: true });
+        writeFileSync(learnStatePath, JSON.stringify(payload, null, 2) + "\n", "utf8");
+    }
+    const activationRoot = parsed.activationRoot;
+    const persistedState = loadPersistedLearnCliState();
+    const stores = discoverOpenClawSessionStores();
+    if (stores.length === 0) {
+        const labelFlow = {
+            source: "missing",
+            humanLabelCount: 0,
+            selfLabelCount: 0,
+            asyncTeacherArtifactCount: 0,
+            implicitPositiveCount: 0,
+            detail: "no local session stores were found"
+        };
+        const learningPath = summarizeLearningPathFromMaterialization(null);
+        if (parsed.json) {
+            console.log(JSON.stringify({
+                command: "learn",
+                activationRoot,
+                scannedSessions: 0,
+                newEvents: 0,
+                loadedState: persistedState.loaded,
+                statePath: learnStatePath,
+                stateResetReason: persistedState.resetReason,
+                materialized: null,
+                promoted: false,
+                graph: null,
+                labelFlow,
+                learningPath,
+                message: "No local session stores found."
+            }));
+        }
+        else {
+            console.log("No new session data. Brain is up to date.");
+        }
+        return 0;
+    }
+    let totalSessions = 0;
+    const allInteractionEvents = [];
+    const allFeedbackEvents = [];
+    let nextSequence = 1;
+    const discoveredSessions = stores
+        .flatMap((store) => {
+        const sessionIndex = loadOpenClawSessionIndex(store.indexPath);
+        return Object.entries(sessionIndex).map(([sessionKey, entry]) => ({
+            store,
+            sessionKey,
+            entry
+        }));
+    })
         .sort((left, right) => {
         if (left.entry.updatedAt !== right.entry.updatedAt) {
             return left.entry.updatedAt - right.entry.updatedAt;
@@ -1326,7 +2272,20 @@ function runLearnCommand(parsed) {
             return left.store.indexPath.localeCompare(right.store.indexPath);
         }
         return left.sessionKey.localeCompare(right.sessionKey);
-    });
+    })
+        .filter((() => {
+        const seenSessionIds = new Set();
+        return (session) => {
+            const sessionId = session.entry.sessionId;
+            if (sessionId !== undefined && seenSessionIds.has(sessionId)) {
+                return false;
+            }
+            if (sessionId !== undefined) {
+                seenSessionIds.add(sessionId);
+            }
+            return true;
+        };
+    })());
     for (const session of discoveredSessions) {
         const sessionFile = session.entry.sessionFile;
         const records = typeof sessionFile !== "string" || sessionFile.trim().length === 0
@@ -1348,24 +2307,75 @@ function runLearnCommand(parsed) {
         });
         nextSequence = sessionExport.nextSequence;
         totalSessions += 1;
-        totalInteractionEvents += sessionExport.interactionEvents.length;
-        totalFeedbackEvents += sessionExport.feedbackEvents.length;
         allInteractionEvents.push(...sessionExport.interactionEvents);
         allFeedbackEvents.push(...sessionExport.feedbackEvents);
     }
-    const totalEvents = totalInteractionEvents + totalFeedbackEvents;
+    const seenInteractionIds = new Set();
+    const dedupedInteractionEvents = [];
+    for (const event of allInteractionEvents) {
+        if (!seenInteractionIds.has(event.eventId)) {
+            seenInteractionIds.add(event.eventId);
+            dedupedInteractionEvents.push(event);
+        }
+    }
+    const seenFeedbackIds = new Set();
+    const dedupedFeedbackEvents = [];
+    for (const event of allFeedbackEvents) {
+        if (!seenFeedbackIds.has(event.eventId)) {
+            seenFeedbackIds.add(event.eventId);
+            dedupedFeedbackEvents.push(event);
+        }
+    }
+    const totalEvents = dedupedInteractionEvents.length + dedupedFeedbackEvents.length;
+    const now = new Date().toISOString();
+    const normalizedEventExport = totalEvents === 0
+        ? null
+        : buildNormalizedEventExport({
+            interactionEvents: dedupedInteractionEvents,
+            feedbackEvents: dedupedFeedbackEvents
+        });
+    const teacherArtifacts = normalizedEventExport === null
+        ? []
+        : buildTeacherSupervisionArtifactsFromNormalizedEventExport({
+            normalizedEventExport,
+            observedAt: now
+        });
+    const labelFlow = normalizedEventExport === null
+        ? {
+            source: "missing",
+            humanLabelCount: 0,
+            selfLabelCount: 0,
+            asyncTeacherArtifactCount: 0,
+            implicitPositiveCount: 0,
+            detail: "no normalized learning export was built"
+        }
+        : summarizeNormalizedEventExportLabelFlow(normalizedEventExport, teacherArtifacts.length);
     if (totalEvents === 0) {
         if (parsed.json) {
-            console.log(JSON.stringify({ command: "learn", activationRoot, scannedSessions: totalSessions, newEvents: 0, materialized: null, promoted: false, message: "No new session data. Brain is up to date." }));
+            console.log(JSON.stringify({
+                command: "learn",
+                activationRoot,
+                scannedSessions: totalSessions,
+                newEvents: 0,
+                loadedState: persistedState.loaded,
+                statePath: learnStatePath,
+                stateResetReason: persistedState.resetReason,
+                materialized: null,
+                promoted: false,
+                graph: null,
+                labelFlow,
+                learningPath: summarizeLearningPathFromMaterialization(null),
+                message: "No new session data. Brain is up to date."
+            }));
         }
         else {
             console.log("No new session data. Brain is up to date.");
         }
         return 0;
     }
-    // 3. Run single learning cycle
-    const now = new Date().toISOString();
-    const learnerResult = advanceAlwaysOnLearningRuntime({
+    const learningExport = normalizedEventExport;
+    const serveTimeLearning = resolveServeTimeLearningRuntimeInput(activationRoot);
+    const learnerResult = drainAlwaysOnLearningRuntime({
         packLabel: "learn-cli",
         workspace: {
             workspaceId: "learn-cli",
@@ -1374,17 +2384,58 @@ function runLearnCommand(parsed) {
             rootDir: activationRoot,
             revision: "learn-cli-v1"
         },
-        interactionEvents: allInteractionEvents,
-        feedbackEvents: allFeedbackEvents,
+        interactionEvents: dedupedInteractionEvents,
+        feedbackEvents: dedupedFeedbackEvents,
+        teacherSupervisionArtifacts: teacherArtifacts,
         learnedRouting: true,
-        state: createAlwaysOnLearningRuntimeState(),
-        builtAt: now
+        state: persistedState.state,
+        builtAt: now,
+        maxCycles: 16,
+        pgVersion: serveTimeLearning.pgVersion,
+        ...(serveTimeLearning.decisionLogCount > 0 ? { serveTimeDecisions: serveTimeLearning.serveTimeDecisions } : {}),
+        ...(serveTimeLearning.baselineState !== undefined ? { baselineState: serveTimeLearning.baselineState } : {})
     });
-    // 4. If materialization produced, materialize → stage → promote
-    if (learnerResult.materialization !== null) {
+    const lastMaterialization = learnerResult.materializations.at(-1) ?? null;
+    const plan = describeAlwaysOnLearningRuntimeState(learnerResult.state, lastMaterialization);
+    const learningPath = summarizeLearningPathFromMaterialization(lastMaterialization);
+    const supervisionCount = lastMaterialization?.candidate.summary.learnedRouter.supervisionCount ?? 0;
+    const routerUpdateCount = lastMaterialization?.candidate.summary.learnedRouter.updateCount ?? 0;
+    const routerNoOpReason = lastMaterialization?.candidate.summary.learnedRouter.noOpReason ?? null;
+    const graphEvolution = lastMaterialization?.candidate.payloads.graph.evolution;
+    const graphSummary = graphEvolution === undefined
+        ? null
+        : {
+            structuralOps: graphEvolution.structuralOps,
+            connectDiagnostics: graphEvolution.connectDiagnostics ?? null
+        };
+    const connectSummary = graphSummary?.connectDiagnostics === null || graphSummary?.connectDiagnostics === undefined
+        ? ""
+        : ` connect candidates=${graphSummary.connectDiagnostics.candidatePairCount} applied=${graphSummary.connectDiagnostics.appliedPairCount} edges=${graphSummary.connectDiagnostics.createdEdgeCount}.`;
+    const routingBuild = lastMaterialization?.candidate.routingBuild ?? {
+        learnedRoutingPath: serveTimeLearning.pgVersion === "v2" ? "policy_gradient_v2" : "policy_gradient_v1",
+        pgVersionRequested: serveTimeLearning.pgVersion,
+        pgVersionUsed: serveTimeLearning.pgVersion,
+        decisionLogCount: serveTimeLearning.decisionLogCount,
+        fallbackReason: serveTimeLearning.pgVersion === "v1" ? serveTimeLearning.fallbackReason ?? "no_serve_time_decisions" : null,
+        updatedBaseline: null
+    };
+    const learnPathReport = {
+        ...routingBuild,
+        fallbackReason: routingBuild.fallbackReason ??
+            (routingBuild.pgVersionUsed === "v1" ? serveTimeLearning.fallbackReason ?? "no_serve_time_decisions" : null)
+    };
+    let promoted = false;
+    let materializedPackId = null;
+    let baselinePersisted = false;
+    const latestTeacherFreshness = teacherArtifacts.length === 0
+        ? "none"
+        : teacherArtifacts.some((artifact) => artifact.freshness.status === "fresh")
+            ? "fresh"
+            : "stale";
+    if (lastMaterialization !== null) {
         const candidatePackRoot = path.join(activationRoot, "packs", `learn-cli-${Date.now()}`);
         mkdirSync(candidatePackRoot, { recursive: true });
-        const candidateDescriptor = materializeAlwaysOnLearningCandidatePack(candidatePackRoot, learnerResult.materialization);
+        const candidateDescriptor = materializeAlwaysOnLearningCandidatePack(candidatePackRoot, lastMaterialization);
         stageCandidatePack(activationRoot, candidatePackRoot, {
             updatedAt: now,
             reason: "learn_cli_stage"
@@ -1393,37 +2444,111 @@ function runLearnCommand(parsed) {
             updatedAt: now,
             reason: "learn_cli_promote"
         });
-        const packId = candidateDescriptor.manifest.packId;
-        if (parsed.json) {
-            console.log(JSON.stringify({
-                command: "learn",
-                activationRoot,
-                scannedSessions: totalSessions,
-                newEvents: totalEvents,
-                materialized: packId,
-                promoted: true,
-                message: `Scanned ${totalSessions} sessions, ${totalEvents} new events, materialized ${packId}, promoted.`
-            }, null, 2));
-        }
-        else {
-            console.log(`Scanned ${totalSessions} sessions, ${totalEvents} new events, materialized ${packId}, promoted.`);
+        if (learnPathReport.pgVersionUsed === "v2" && learnPathReport.updatedBaseline !== null) {
+            persistBaseline(activationRoot, learnPathReport.updatedBaseline);
+            baselinePersisted = true;
+        }
+        materializedPackId = candidateDescriptor.manifest.packId;
+        promoted = true;
+    }
+    persistLearnCliState(learnerResult.state, now);
+    writeJsonFile(teacherSnapshotPath, {
+        runtimeOwner: "openclaw",
+        queue: {
+            capacity: 1,
+            depth: 0,
+            running: false
+        },
+        teacher: {
+            artifactCount: teacherArtifacts.length,
+            artifacts: teacherArtifacts,
+            latestFreshness: latestTeacherFreshness
+        },
+        learner: {
+            state: learnerResult.state,
+            lastMaterialization
+        },
+        diagnostics: {
+            acceptedExportCount: 1,
+            processedExportCount: 1,
+            duplicateExportCount: 0,
+            droppedExportCount: 0,
+            emittedArtifactCount: teacherArtifacts.length,
+            dedupedArtifactCount: 0,
+            lastProcessedAt: now,
+            latestFreshness: latestTeacherFreshness,
+            lastNoOpReason: teacherArtifacts.length === 0 ? "no_teacher_artifacts" : "none",
+            notes: [
+                `learn-cli export=${learningExport.provenance.exportDigest} range=${learningExport.range.start}-${learningExport.range.end}/${learningExport.range.count}`,
+                `teacher artifacts=${teacherArtifacts.length} freshness=${latestTeacherFreshness}`,
+                `last materialized pack=${materializedPackId ?? "none"}`
+            ]
+        },
+        state: {
+            interactionEvents: learningExport.interactionEvents,
+            feedbackEvents: learningExport.feedbackEvents,
+            seenExportDigests: [learningExport.provenance.exportDigest]
+        },
+        runtime: {
+            startedAt: now,
+            lastHeartbeatAt: now,
+            lastScanAt: now,
+            scanRoot: null,
+            lastAppliedMaterializationJobId: lastMaterialization?.jobId ?? null
         }
+    });
+    const summaryMessage = materializedPackId === null
+        ? `Scanned ${totalSessions} sessions, ${totalEvents} new events, no candidate materialized, no promotion.`
+        : `Scanned ${totalSessions} sessions, ${totalEvents} new events, materialized ${materializedPackId}, promoted.${connectSummary}`;
+    if (parsed.json) {
+        console.log(JSON.stringify({
+            command: "learn",
+            activationRoot,
+            scannedSessions: totalSessions,
+            newEvents: totalEvents,
+            loadedState: persistedState.loaded,
+            statePath: learnStatePath,
+            stateResetReason: persistedState.resetReason,
+            drain: {
+                cyclesRun: learnerResult.cycles.length,
+                stopReason: learnerResult.stopReason,
+                drained: learnerResult.drained,
+                materializationCount: learnerResult.materializations.length
+            },
+            learner: {
+                teacherBudget: learnerResult.state.sparseFeedback.teacherBudget,
+                eligibleFeedbackCount: learnerResult.state.sparseFeedback.eligibleFeedbackCount,
+                budgetedOutFeedbackCount: learnerResult.state.sparseFeedback.budgetedOutFeedbackCount,
+                supervisionCount,
+                routerUpdateCount,
+                routerNoOpReason,
+                pending: plan.pending,
+                learnedRange: plan.learnedRange
+            },
+            materialized: materializedPackId,
+            promoted,
+            graph: graphSummary,
+            labelFlow,
+            learningPath,
+            learnedRoutingPath: learnPathReport.learnedRoutingPath,
+            pgVersionRequested: learnPathReport.pgVersionRequested,
+            pgVersionUsed: learnPathReport.pgVersionUsed,
+            decisionLogCount: learnPathReport.decisionLogCount,
+            fallbackReason: learnPathReport.fallbackReason,
+            baselinePersisted,
+            message: summaryMessage
+        }, null, 2));
     }
     else {
-        if (parsed.json) {
-            console.log(JSON.stringify({
-                command: "learn",
-                activationRoot,
-                scannedSessions: totalSessions,
-                newEvents: totalEvents,
-                materialized: null,
-                promoted: false,
-                message: "No new session data. Brain is up to date."
-            }, null, 2));
-        }
-        else {
-            console.log("No new session data. Brain is up to date.");
-        }
+        const text = materializedPackId === null
+            ? `Scanned ${totalSessions} sessions, ${totalEvents} new events, no promotion. cycles=${learnerResult.cycles.length} stop=${learnerResult.stopReason} supervision=${supervisionCount}.`
+            : `Scanned ${totalSessions} sessions, ${totalEvents} new events, materialized ${materializedPackId}, promoted.${connectSummary} cycles=${learnerResult.cycles.length} supervision=${supervisionCount}.`;
+        console.log(text);
+        console.log(`labels: source=${labelFlow.source} human=${labelFlow.humanLabelCount ?? "none"} self=${labelFlow.selfLabelCount ?? "none"} implicitPositive=${labelFlow.implicitPositiveCount ?? "none"} teacherArtifacts=${labelFlow.asyncTeacherArtifactCount ?? "none"}`);
+        console.log(`path: source=${learningPath.source} pg=${learningPath.policyGradientVersion} method=${learningPath.policyGradientMethod ?? "none"} target=${learningPath.targetConstruction ?? "none"} connect=${learningPath.connectOpsFired ?? "none"} trajectories=${learningPath.reconstructedTrajectoryCount ?? "none"}`);
+        console.log(`learned routing: path=${learnPathReport.learnedRoutingPath} pg=${learnPathReport.pgVersionUsed ?? "n/a"} decisions=${learnPathReport.decisionLogCount}` +
+            `${learnPathReport.fallbackReason === null ? "" : ` fallback=${learnPathReport.fallbackReason}`}` +
+            `${learnPathReport.pgVersionUsed === "v2" ? ` baseline=${baselinePersisted ? "persisted" : "unchanged"}` : ""}`);
     }
     return 0;
 }
@@ -1434,26 +2559,553 @@ function formatTimestamp() {
 function watchLog(message) {
     console.log(`${formatTimestamp()} ${message}`);
 }
-async function runWatchCommand(parsed) {
-    const activationRoot = parsed.activationRoot;
-    const scanRoot = parsed.scanRoot !== null
-        ? path.resolve(parsed.scanRoot)
+function formatWatchError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function sanitizeWatchPathSegment(value) {
+    const sanitized = value
+        .replace(/[^a-zA-Z0-9._-]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 96);
+    return sanitized.length > 0 ? sanitized : "session";
+}
+function readOptionalJsonFile(filePath) {
+    if (!existsSync(filePath)) {
+        return null;
+    }
+    try {
+        return JSON.parse(readFileSync(filePath, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function writeJsonFile(filePath, value) {
+    mkdirSync(path.dirname(filePath), { recursive: true });
+    writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+function loadWatchSessionTailCursor(cursorPath) {
+    const parsed = readOptionalJsonFile(cursorPath);
+    if (Array.isArray(parsed)) {
+        return parsed;
+    }
+    if (parsed !== null && Array.isArray(parsed.cursor)) {
+        return parsed.cursor;
+    }
+    return [];
+}
+function persistWatchSessionTailCursor(cursorPath, cursor) {
+    writeJsonFile(cursorPath, {
+        contract: "openclaw_watch_session_tail_cursor.v1",
+        runtimeOwner: "openclaw",
+        updatedAt: new Date().toISOString(),
+        cursor
+    });
+}
+function countWatchCursorBridgedEvents(cursor) {
+    return cursor.reduce((sum, entry) => sum + entry.bridgedEventCount, 0);
+}
+function listWatchRuntimeEventExportBundleRoots(scanRoot) {
+    if (!existsSync(scanRoot)) {
+        return [];
+    }
+    return readdirSync(scanRoot, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => path.join(scanRoot, entry.name))
+        .sort((left, right) => left.localeCompare(right));
+}
+async function replayWatchScanRootIntoTeacherLoop(teacherLoop, scanRoot) {
+    const seenExportDigests = new Set();
+    const bundles = listWatchRuntimeEventExportBundleRoots(scanRoot)
+        .map((rootDir) => {
+        try {
+            return loadRuntimeEventExportBundle(rootDir);
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((bundle) => bundle !== null)
+        .sort((left, right) => {
+        const exportedAtCompare = left.manifest.exportedAt.localeCompare(right.manifest.exportedAt);
+        if (exportedAtCompare !== 0) {
+            return exportedAtCompare;
+        }
+        if (left.normalizedEventExport.range.start !== right.normalizedEventExport.range.start) {
+            return left.normalizedEventExport.range.start - right.normalizedEventExport.range.start;
+        }
+        if (left.normalizedEventExport.range.end !== right.normalizedEventExport.range.end) {
+            return left.normalizedEventExport.range.end - right.normalizedEventExport.range.end;
+        }
+        return left.normalizedEventExport.provenance.exportDigest.localeCompare(right.normalizedEventExport.provenance.exportDigest);
+    });
+    let replayedBundleCount = 0;
+    let replayedEventCount = 0;
+    for (const bundle of bundles) {
+        const exportDigest = bundle.normalizedEventExport.provenance.exportDigest;
+        if (seenExportDigests.has(exportDigest)) {
+            continue;
+        }
+        seenExportDigests.add(exportDigest);
+        let enqueue = teacherLoop.enqueueNormalizedEventExport(bundle.normalizedEventExport, {
+            observedAt: bundle.manifest.exportedAt
+        });
+        if (!enqueue.accepted && enqueue.reason === "queue_full") {
+            await teacherLoop.flush();
+            enqueue = teacherLoop.enqueueNormalizedEventExport(bundle.normalizedEventExport, {
+                observedAt: bundle.manifest.exportedAt
+            });
+        }
+        if (!enqueue.accepted) {
+            continue;
+        }
+        replayedBundleCount += 1;
+        replayedEventCount += bundle.normalizedEventExport.range.count;
+    }
+    if (replayedBundleCount > 0) {
+        await teacherLoop.flush();
+    }
+    return {
+        replayedBundleCount,
+        replayedEventCount
+    };
+}
+function exportLocalSessionTailChangesToScanRoot(input) {
+    let exportedBundleCount = 0;
+    let exportedEventCount = 0;
+    const warnings = [];
+    for (const change of input.changes) {
+        if (change.scannedEventExport === null) {
+            continue;
+        }
+        const built = buildNormalizedEventExportFromScannedEvents(change.scannedEventExport);
+        if (!built.ok) {
+            warnings.push(`${change.sessionKey}: ${built.error}`);
+            continue;
+        }
+        const exportDigest = built.normalizedEventExport.provenance.exportDigest.replace(/^sha256-/u, "");
+        const exportName = `session-tail-${sanitizeWatchPathSegment(change.sessionKey)}-${built.normalizedEventExport.range.start}-${built.normalizedEventExport.range.end}-${exportDigest.slice(0, 12)}`;
+        const result = writeScannedEventExportBundle({
+            rootDir: path.join(input.scanRoot, exportName),
+            exportName,
+            exportedAt: input.polledAt,
+            scannedEventExport: change.scannedEventExport
+        });
+        if (!result.ok) {
+            warnings.push(`${change.sessionKey}: ${result.error}`);
+            continue;
+        }
+        exportedBundleCount += 1;
+        exportedEventCount += result.normalizedEventExport.range.count;
+    }
+    return {
+        exportedBundleCount,
+        exportedEventCount,
+        warnings
+    };
+}
+function applyWatchMaterialization(activationRoot, snapshot, lastHandledMaterializationPackId) {
+    const materialization = snapshot?.learner?.lastMaterialization ?? null;
+    if (materialization === null) {
+        return {
+            lastHandledMaterializationPackId,
+            logLine: null,
+            materializedPackId: null,
+            failure: null
+        };
+    }
+    const packId = typeof materialization?.candidate?.summary?.packId === "string"
+        ? materialization.candidate.summary.packId
+        : null;
+    if (packId === null || packId === lastHandledMaterializationPackId) {
+        return {
+            lastHandledMaterializationPackId,
+            logLine: null,
+            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 });
+        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,
+            reason: `watch_stage:${materialization.reason}:${materialization.lane}`
+        });
+        const inspection = inspectActivationState(activationRoot, now);
+        if (inspection.promotion.allowed) {
+            promoteCandidatePack(activationRoot, {
+                updatedAt: now,
+                reason: `watch_promote:${materialization.reason}:${materialization.lane}`
+            });
+            return {
+                lastHandledMaterializationPackId: packId,
+                materializedPackId: packId,
+                logLine: `Promoted ${shortPackId} → active`,
+                failure: null
+            };
+        }
+        return {
+            lastHandledMaterializationPackId: packId,
+            materializedPackId: packId,
+            logLine: `Staged ${shortPackId} (promotion blocked: ${inspection.promotion.findings.join(", ")})`,
+            failure: null
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            lastHandledMaterializationPackId,
+            materializedPackId: packId,
+            logLine: `Promotion failed for ${shortPackId}: ${message}`,
+            failure: {
+                mode: "materialization_failed",
+                detail: message,
+                at: new Date().toISOString()
+            }
+        };
+    }
+}
+function resolveWatchTeacherLabelerConfig(input) {
+    if (input !== undefined) {
+        return {
+            teacherLabeler: input,
+            warnings: []
+        };
+    }
+    const providerConfig = readOpenClawBrainProviderConfig(process.env);
+    const warnings = providerConfig.warnings.filter((warning) => /OPENCLAWBRAIN_TEACHER_/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 intervalMs = parsed.interval * 1000;
-    watchLog(`Watch starting — activation: ${shortenPath(activationRoot)}`);
-    watchLog(`Scan root: ${shortenPath(scanRoot)}  interval: ${parsed.interval}s`);
+    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);
+    const teacherLabeler = resolvedTeacherLabeler.teacherLabeler;
+    for (const warning of resolvedTeacherLabeler.warnings) {
+        startupWarnings.push(`teacher_env_warning:${warning}`);
+        log(`Teacher env warning: ${warning}`);
+    }
+    if (teacherLabeler?.provider === "ollama") {
+        log(`Teacher labeler: provider=ollama model=${teacherLabeler.model ?? "qwen3.5:9b"}`);
+    }
     const scanner = createRuntimeEventExportScanner({ scanRoot });
-    const teacherLoop = createAsyncTeacherLiveLoop({
+    let lastServeTimeFallbackReason = null;
+    const baseTeacherLoopInput = {
         packLabel: "watch-cli",
         workspace: {
             workspaceId: "watch-cli",
             snapshotId: `watch-cli@${new Date().toISOString().slice(0, 10)}`,
             capturedAt: new Date().toISOString(),
             rootDir: activationRoot,
-            revision: "watch-cli-v1"
+            revision: "watch-cli-v2"
         },
-        learnedRouting: true
+        learnedRouting: true,
+        ...(teacherLabeler !== null ? { teacherLabeler } : {}),
+        resolveLearnedRoutingState: () => {
+            const resolved = resolveServeTimeLearningRuntimeInput(activationRoot);
+            if (resolved.fallbackReason !== null && resolved.fallbackReason !== lastServeTimeFallbackReason) {
+                log(`Serve-time routing fallback: ${resolved.fallbackReason}`);
+            }
+            lastServeTimeFallbackReason = resolved.fallbackReason;
+            return {
+                pgVersion: resolved.pgVersion,
+                ...(resolved.decisionLogCount > 0 ? { serveTimeDecisions: resolved.serveTimeDecisions } : {}),
+                ...(resolved.baselineState !== undefined ? { baselineState: resolved.baselineState } : {})
+            };
+        },
+        persistUpdatedBaseline: (state) => {
+            try {
+                persistBaseline(activationRoot, state);
+            }
+            catch (error) {
+                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 {
+        localSessionTail = createOpenClawLocalSessionTail({
+            ...(input.profileRoots === undefined ? {} : { profileRoots: input.profileRoots }),
+            cursor: restoredCursor,
+            emitExistingOnFirstPoll: restoredCursor.length === 0
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        log(`Session tail cursor reset: ${message}`);
+        restoredCursor = [];
+        localSessionTail = createOpenClawLocalSessionTail({
+            ...(input.profileRoots === undefined ? {} : { profileRoots: input.profileRoots }),
+            emitExistingOnFirstPoll: true
+        });
+        persistWatchSessionTailCursor(sessionTailCursorPath, []);
+    }
+    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"})`);
+    }
+    let bootstrapSnapshot = teacherLoop.snapshot();
+    const replayPromotion = applyWatchMaterialization(activationRoot, bootstrapSnapshot, lastHandledMaterializationPackId);
+    lastHandledMaterializationPackId = replayPromotion.lastHandledMaterializationPackId;
+    if (replayPromotion.logLine !== null) {
+        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 {
+        activationRoot,
+        scanRoot,
+        sessionTailCursorPath,
+        teacherSnapshotPath,
+        startupWarnings,
+        lastTeacherError: null,
+        replayState,
+        lastHandledMaterializationPackId,
+        scanner,
+        teacherLoop,
+        localSessionTail
+    };
+}
+export async function runWatchCommandPass(runtime, options = {}) {
+    const log = options.log ?? watchLog;
+    const observedAt = options.observedAt ?? new Date().toISOString();
+    const localPoll = runtime.localSessionTail.pollOnce({
+        observedAt
+    });
+    const scannerCheckpointBeforeScan = runtime.scanner.snapshot();
+    const exported = exportLocalSessionTailChangesToScanRoot({
+        scanRoot: runtime.scanRoot,
+        polledAt: localPoll.polledAt,
+        changes: localPoll.changes
+    });
+    persistWatchSessionTailCursor(runtime.sessionTailCursorPath, localPoll.cursor);
+    for (const warning of [...localPoll.warnings, ...exported.warnings]) {
+        log(`Session tail warning: ${warning}`);
+    }
+    if (exported.exportedBundleCount > 0) {
+        log(`Session tail exported ${exported.exportedBundleCount} bundle${exported.exportedBundleCount === 1 ? "" : "s"} from ${localPoll.changes.length} changed session${localPoll.changes.length === 1 ? "" : "s"}`);
+    }
+    const scanResult = runtime.scanner.scanOnce({
+        scannedAt: observedAt
     });
+    const totalSelected = scanResult.selected.length;
+    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"}`);
+        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,
+            replayedBundles: runtime.replayState.replayedBundleCount,
+            replayedEvents: runtime.replayState.replayedEventCount,
+            exportedBundles: exported.exportedBundleCount,
+            exportedEvents: exported.exportedEventCount,
+            selected: totalSelected,
+            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
+        }));
+    }
+    return {
+        localPoll,
+        exported,
+        scanResult,
+        snapshot,
+        materializedPackId
+    };
+}
+async function runWatchCommand(parsed) {
+    const intervalMs = parsed.interval * 1000;
+    const runtime = await createWatchCommandRuntime({
+        activationRoot: parsed.activationRoot,
+        scanRoot: parsed.scanRoot,
+        log: watchLog
+    });
+    watchLog(`Interval: ${parsed.interval}s`);
     let stopping = false;
     const onSignal = () => {
         if (stopping) {
@@ -1466,69 +3118,15 @@ async function runWatchCommand(parsed) {
     process.on("SIGTERM", onSignal);
     while (!stopping) {
         try {
-            const scanResult = scanner.scanOnce();
-            const liveCount = scanResult.live.length;
-            const backfillCount = scanResult.backfill.length;
-            const totalSelected = scanResult.selected.length;
-            if (totalSelected === 0) {
-                watchLog("Scanning... no changes");
-            }
-            else {
-                const totalEvents = scanResult.selected.reduce((sum, hit) => sum + hit.eventRange.count, 0);
-                watchLog(`Scanning... ${totalSelected} session${totalSelected === 1 ? "" : "s"} changed, ${totalEvents} new event${totalEvents === 1 ? "" : "s"}`);
-                // Feed exports into teacher/learner pipeline
-                const ingestResult = await teacherLoop.ingestRuntimeEventExportScannerScan(scanResult);
-                const snapshot = ingestResult.snapshot;
-                const materialization = snapshot.learner.lastMaterialization;
-                if (materialization !== null) {
-                    const packId = materialization.candidate.summary.packId;
-                    const shortPackId = packId.length > 16 ? packId.slice(0, 16) : packId;
-                    watchLog(`Learning: materialized ${shortPackId}`);
-                    // Attempt stage + promote
-                    try {
-                        const candidateRootDir = path.resolve(activationRoot, "packs", packId);
-                        mkdirSync(candidateRootDir, { recursive: true });
-                        materializeAlwaysOnLearningCandidatePack(candidateRootDir, materialization);
-                        const now = new Date().toISOString();
-                        stageCandidatePack(activationRoot, candidateRootDir, {
-                            updatedAt: now,
-                            reason: `watch_stage:${materialization.reason}:${materialization.lane}`
-                        });
-                        const inspection = inspectActivationState(activationRoot, now);
-                        if (inspection.promotion.allowed) {
-                            promoteCandidatePack(activationRoot, {
-                                updatedAt: now,
-                                reason: `watch_promote:${materialization.reason}:${materialization.lane}`
-                            });
-                            watchLog(`Promoted ${shortPackId} → active`);
-                        }
-                        else {
-                            watchLog(`Staged ${shortPackId} (promotion blocked: ${inspection.promotion.findings.join(", ")})`);
-                        }
-                    }
-                    catch (error) {
-                        const message = error instanceof Error ? error.message : String(error);
-                        watchLog(`Promotion failed: ${message}`);
-                    }
-                }
-                if (parsed.json) {
-                    console.log(JSON.stringify({
-                        timestamp: new Date().toISOString(),
-                        selected: totalSelected,
-                        events: totalEvents,
-                        live: liveCount,
-                        backfill: backfillCount,
-                        materialized: materialization?.candidate.summary.packId ?? null,
-                        diagnostics: snapshot.diagnostics
-                    }));
-                }
-            }
+            await runWatchCommandPass(runtime, {
+                json: parsed.json,
+                log: watchLog
+            });
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
             watchLog(`Error: ${message}`);
         }
-        // Wait for the next interval, checking for stop signal periodically
         const deadline = Date.now() + intervalMs;
         while (!stopping && Date.now() < deadline) {
             await new Promise((resolve) => {
@@ -1590,12 +3188,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"
@@ -1646,7 +3245,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;
 }
@@ -1721,8 +3320,14 @@ export function runOperatorCli(argv = process.argv.slice(2)) {
         });
         return 0;
     }
-    if (parsed.command === "setup") {
-        return runSetupCommand(parsed);
+    if (parsed.command === "install") {
+        return runInstallCommand(parsed);
+    }
+    if (parsed.command === "detach") {
+        return runDetachCommand(parsed);
+    }
+    if (parsed.command === "uninstall") {
+        return runUninstallCommand(parsed);
     }
     if (parsed.command === "attach") {
         mkdirSync(parsed.activationRoot, { recursive: true });
@@ -1786,7 +3391,7 @@ 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);
     if (statusOrRollback.command === "rollback") {
         const result = rollbackRuntimeAttach({
             activationRoot,
@@ -1801,18 +3406,17 @@ export function runOperatorCli(argv = process.argv.slice(2)) {
         }
         return result.allowed ? 0 : 1;
     }
-    const status = describeCurrentProfileBrainStatus({
+    const operatorInput = {
         ...statusOrRollback.input,
-        activationRoot
-    });
+        activationRoot,
+        teacherSnapshotPath: resolveOperatorTeacherSnapshotPath(activationRoot, statusOrRollback.input.teacherSnapshotPath)
+    };
+    const status = describeCurrentProfileBrainStatus(operatorInput);
     if (statusOrRollback.json) {
         console.log(JSON.stringify(status, null, 2));
     }
     else {
-        const report = buildOperatorSurfaceReport({
-            ...statusOrRollback.input,
-            activationRoot
-        });
+        const report = buildOperatorSurfaceReport(operatorInput);
         if (statusOrRollback.detailed) {
             console.log(formatCurrentProfileStatusSummary(status, report));
         }