@openclawbrain/openclaw 0.1.12 → 0.2.1

package/dist/src/cli.js

@@ -1,8 +1,18 @@
 #!/usr/bin/env node
-import { mkdirSync, readFileSync, realpathSync, statSync, writeFileSync } from "node:fs";
+import { execSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, readdirSync, readSync, openSync, closeSync, realpathSync, rmSync, statSync, writeFileSync, appendFileSync } from "node:fs";
 import path from "node:path";
-import { pathToFileURL } from "node:url";
-import { buildOperatorSurfaceReport, describeCurrentProfileBrainStatus, formatOperatorRollbackReport, loadRuntimeEventExportBundle, rollbackRuntimeAttach, scanLiveEventExport, scanRecordedSession } from "./index.js";
+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 { resolveActivationRoot } from "./resolve-activation-root.js";
+import { bootstrapRuntimeAttach, buildOperatorSurfaceReport, compileRuntimeContext, createAsyncTeacherLiveLoop, createRuntimeEventExportScanner, describeCurrentProfileBrainStatus, formatBootstrapRuntimeAttachReport, formatOperatorRollbackReport, loadRuntimeEventExportBundle, rollbackRuntimeAttach, scanLiveEventExport, scanRecordedSession } from "./index.js";
+import { buildPassiveLearningSessionExportFromOpenClawSessionStore } from "./local-session-passive-learning.js";
+import { discoverOpenClawMainSessionStores, loadOpenClawSessionIndex, readOpenClawSessionFile } from "./session-store.js";
 function quoteShellArg(value) {
     return `'${value.replace(/'/g, `"'"'`)}'`;
 }
@@ -122,18 +132,30 @@ function buildDoctorDeletedMessage(args) {
 function operatorCliHelp() {
     return [
         "Usage:",
+        "  openclawbrain setup --openclaw-home <path> [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 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-ops scan --session <trace.json> --root <path> [options]    # compatibility alias",
         "",
         "Options:",
-        "  --activation-root <path>    Activation root to inspect.",
+        "  --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.",
+        "  --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').",
         "  --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.",
         "  --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).",
         "  --dry-run                   Preview rollback pointer movement without writing activation state.",
         "  --session <path>            Sanitized recorded-session trace JSON to replay.",
         "  --live <path>               Runtime event-export bundle root or normalized export JSON to scan once.",
@@ -142,11 +164,15 @@ function operatorCliHelp() {
         "  --pack-label <label>        Candidate-pack label for scan --live. Defaults to scanner-live-cli.",
         "  --observed-at <iso>         Observation time for scan --live freshness checks.",
         "  --snapshot-out <path>       Write the one-shot scan --live snapshot JSON.",
+        "  --limit <N>                 Maximum number of history entries to show (default: 20, history only).",
+        "  --scan-root <path>          Event-export scan root for watch mode (defaults to <activation-root>/event-exports).",
+        "  --interval <seconds>        Polling interval for watch mode (default: 30).",
         "  --json                      Emit machine-readable JSON instead of text.",
         "  --help                      Show this help.",
         "",
         "Common flow:",
-        "  0. bootstrap  call bootstrapRuntimeAttach({ profileSelector: \"current_profile\", ... }) to attach an initial pack",
+        "  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",
@@ -222,11 +248,49 @@ function formatCurrentProfileStatusSummary(status, report) {
         `turn        attribution=${status.currentTurnAttribution === null ? "none" : status.currentTurnAttribution.contract}`
     ].join("\n");
 }
-function requireActivationRoot(input, command) {
-    if (input.activationRoot.trim().length === 0) {
-        throw new Error(`--activation-root is required for ${command}`);
+// Auto-detection of activation root is now handled by the shared
+// resolveActivationRoot() helper in resolve-activation-root.ts.
+// It is imported at the top and used by requireActivationRoot below.
+function shortenPath(fullPath) {
+    const homeDir = process.env.HOME ?? "";
+    if (homeDir.length > 0 && fullPath.startsWith(homeDir)) {
+        return "~" + fullPath.slice(homeDir.length);
     }
-    return path.resolve(input.activationRoot);
+    return fullPath;
+}
+function formatHumanFriendlyStatus(status, report) {
+    // Brain status line
+    const brainActive = status.brainStatus.status === "ok" || status.brainStatus.serveState === "serving_active_pack";
+    const brainIcon = brainActive ? "Active ✓" : status.brainStatus.status === "fail" ? "Inactive ✗" : `${status.brainStatus.status}`;
+    // Pack line
+    const packId = status.brain.activePackId ?? "none";
+    const packShort = packId.length > 9 ? packId.slice(0, 9) : packId;
+    const state = status.brain.state ?? "unknown";
+    // Activation root
+    const activationPath = shortenPath(status.host.activationRoot);
+    // Policy
+    const policy = status.attachment.policyMode ?? report.manyProfile.declaredAttachmentPolicy ?? "undeclared";
+    const lines = [
+        `Brain: ${brainIcon}`,
+        `Pack:  ${packShort} (${state})`,
+        `Activation: ${activationPath}`,
+        `Policy: ${policy}`
+    ];
+    // Add learning/serve warnings if relevant
+    if (report.learning.warningStates.length > 0) {
+        lines.push(`Warnings: ${report.learning.warningStates.join(", ")}`);
+    }
+    if (status.brainStatus.awaitingFirstExport) {
+        lines.push(`Note: Awaiting first event export`);
+    }
+    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
+    return resolveActivationRoot({
+        explicit: input.activationRoot.trim().length > 0 ? input.activationRoot : null,
+    });
 }
 function readJsonFile(filePath) {
     return JSON.parse(readFileSync(path.resolve(filePath), "utf8"));
@@ -274,18 +338,336 @@ export function parseOperatorCliArgs(argv) {
     let rootDir = null;
     let workspacePath = null;
     let packLabel = null;
+    let packRoot = null;
+    let workspaceId = null;
     let observedAt = null;
     let snapshotOutPath = null;
+    let openclawHome = null;
+    let shared = false;
     let json = false;
     let help = false;
     let dryRun = false;
+    let detailed = false;
     const args = [...argv];
     if (args[0] === "doctor") {
         throw new Error(buildDoctorDeletedMessage(args.slice(1)));
     }
-    if (args[0] === "status" || args[0] === "rollback" || args[0] === "scan") {
+    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") {
         command = args.shift();
     }
+    if (command === "learn") {
+        for (let index = 0; index < args.length; index += 1) {
+            const arg = args[index];
+            if (arg === "--help" || arg === "-h") {
+                help = true;
+                continue;
+            }
+            if (arg === "--json") {
+                json = true;
+                continue;
+            }
+            if (arg === "--activation-root") {
+                const next = args[index + 1];
+                if (next === undefined) {
+                    throw new Error("--activation-root requires a value");
+                }
+                activationRoot = next;
+                index += 1;
+                continue;
+            }
+            if (arg.startsWith("--")) {
+                throw new Error(`unknown argument for learn: ${arg}`);
+            }
+        }
+        if (help) {
+            return { command, activationRoot: "", json, help };
+        }
+        return {
+            command,
+            activationRoot: resolveActivationRoot({ explicit: activationRoot }),
+            json,
+            help
+        };
+    }
+    if (command === "watch") {
+        let watchScanRoot = null;
+        let watchInterval = 30;
+        for (let index = 0; index < args.length; index += 1) {
+            const arg = args[index];
+            if (arg === "--help" || arg === "-h") {
+                help = true;
+                continue;
+            }
+            if (arg === "--json") {
+                json = true;
+                continue;
+            }
+            if (arg === "--activation-root") {
+                const next = args[index + 1];
+                if (next === undefined) {
+                    throw new Error("--activation-root requires a value");
+                }
+                activationRoot = next;
+                index += 1;
+                continue;
+            }
+            if (arg === "--scan-root") {
+                const next = args[index + 1];
+                if (next === undefined) {
+                    throw new Error("--scan-root requires a value");
+                }
+                watchScanRoot = next;
+                index += 1;
+                continue;
+            }
+            if (arg === "--interval") {
+                const next = args[index + 1];
+                if (next === undefined) {
+                    throw new Error("--interval requires a value");
+                }
+                const parsed = Number.parseInt(next, 10);
+                if (!Number.isInteger(parsed) || parsed < 1) {
+                    throw new Error("--interval must be a positive integer (seconds)");
+                }
+                watchInterval = parsed;
+                index += 1;
+                continue;
+            }
+            if (arg.startsWith("--")) {
+                throw new Error(`unknown argument for watch: ${arg}`);
+            }
+        }
+        if (help) {
+            return { command, activationRoot: "", scanRoot: null, interval: 30, json, help };
+        }
+        return {
+            command,
+            activationRoot: resolveActivationRoot({ explicit: activationRoot }),
+            scanRoot: watchScanRoot,
+            interval: watchInterval,
+            json,
+            help
+        };
+    }
+    if (command === "context") {
+        const messageParts = [];
+        for (let index = 0; index < args.length; index += 1) {
+            const arg = args[index];
+            if (arg === "--help" || arg === "-h") {
+                help = true;
+                continue;
+            }
+            if (arg === "--json") {
+                json = true;
+                continue;
+            }
+            if (arg === "--activation-root") {
+                const next = args[index + 1];
+                if (next === undefined) {
+                    throw new Error("--activation-root requires a value");
+                }
+                activationRoot = next;
+                index += 1;
+                continue;
+            }
+            if (arg.startsWith("--")) {
+                throw new Error(`unknown argument for context: ${arg}`);
+            }
+            messageParts.push(arg);
+        }
+        if (help) {
+            return { command, message: "", activationRoot: "", json, help };
+        }
+        if (messageParts.length === 0) {
+            throw new Error("context requires a message argument: openclawbrain context \"your message\"");
+        }
+        return {
+            command,
+            message: messageParts.join(" "),
+            activationRoot: resolveActivationRoot({ explicit: activationRoot }),
+            json,
+            help
+        };
+    }
+    if (command === "history") {
+        let historyLimit = 20;
+        for (let index = 0; index < args.length; index += 1) {
+            const arg = args[index];
+            if (arg === "--help" || arg === "-h") {
+                help = true;
+                continue;
+            }
+            if (arg === "--json") {
+                json = true;
+                continue;
+            }
+            if (arg === "--activation-root") {
+                const next = args[index + 1];
+                if (next === undefined) {
+                    throw new Error("--activation-root requires a value");
+                }
+                activationRoot = next;
+                index += 1;
+                continue;
+            }
+            if (arg === "--limit") {
+                const next = args[index + 1];
+                if (next === undefined) {
+                    throw new Error("--limit requires a value");
+                }
+                const parsed = Number.parseInt(next, 10);
+                if (!Number.isInteger(parsed) || parsed <= 0) {
+                    throw new Error("--limit must be a positive integer");
+                }
+                historyLimit = parsed;
+                index += 1;
+                continue;
+            }
+            if (arg.startsWith("--")) {
+                throw new Error(`unknown argument for history: ${arg}`);
+            }
+        }
+        if (help) {
+            return { command, activationRoot: "", limit: historyLimit, json, help };
+        }
+        return {
+            command,
+            activationRoot: resolveActivationRoot({ explicit: activationRoot }),
+            limit: historyLimit,
+            json,
+            help
+        };
+    }
+    if (command === "export") {
+        let outputPath = null;
+        for (let index = 0; index < args.length; index += 1) {
+            const arg = args[index];
+            if (arg === "--help" || arg === "-h") {
+                help = true;
+                continue;
+            }
+            if (arg === "--json") {
+                json = true;
+                continue;
+            }
+            if (arg === "--activation-root") {
+                const next = args[index + 1];
+                if (next === undefined)
+                    throw new Error("--activation-root requires a value");
+                activationRoot = next;
+                index += 1;
+                continue;
+            }
+            if (arg === "-o" || arg === "--output") {
+                const next = args[index + 1];
+                if (next === undefined)
+                    throw new Error("-o / --output requires a value");
+                outputPath = next;
+                index += 1;
+                continue;
+            }
+            if (arg.startsWith("--"))
+                throw new Error(`unknown argument for export: ${arg}`);
+        }
+        if (help)
+            return { command, activationRoot: "", outputPath: "", json, help };
+        if (outputPath === null)
+            throw new Error("export requires -o <output.tar.gz>");
+        return {
+            command,
+            activationRoot: resolveActivationRoot({ explicit: activationRoot }),
+            outputPath: path.resolve(outputPath),
+            json,
+            help,
+        };
+    }
+    if (command === "import") {
+        let archivePath = null;
+        let force = false;
+        for (let index = 0; index < args.length; index += 1) {
+            const arg = args[index];
+            if (arg === "--help" || arg === "-h") {
+                help = true;
+                continue;
+            }
+            if (arg === "--json") {
+                json = true;
+                continue;
+            }
+            if (arg === "--force") {
+                force = true;
+                continue;
+            }
+            if (arg === "--activation-root") {
+                const next = args[index + 1];
+                if (next === undefined)
+                    throw new Error("--activation-root requires a value");
+                activationRoot = next;
+                index += 1;
+                continue;
+            }
+            if (arg.startsWith("--"))
+                throw new Error(`unknown argument for import: ${arg}`);
+            if (archivePath === null) {
+                archivePath = arg;
+            }
+            else {
+                throw new Error(`unexpected positional argument: ${arg}`);
+            }
+        }
+        if (help)
+            return { command, archivePath: "", activationRoot: "", force: false, json, help };
+        if (archivePath === null)
+            throw new Error("import requires <backup.tar.gz> argument");
+        return {
+            command,
+            archivePath: path.resolve(archivePath),
+            activationRoot: resolveActivationRoot({ explicit: activationRoot }),
+            force,
+            json,
+            help,
+        };
+    }
+    if (command === "reset") {
+        let yes = false;
+        for (let index = 0; index < args.length; index += 1) {
+            const arg = args[index];
+            if (arg === "--help" || arg === "-h") {
+                help = true;
+                continue;
+            }
+            if (arg === "--json") {
+                json = true;
+                continue;
+            }
+            if (arg === "--yes" || arg === "-y") {
+                yes = true;
+                continue;
+            }
+            if (arg === "--activation-root") {
+                const next = args[index + 1];
+                if (next === undefined)
+                    throw new Error("--activation-root requires a value");
+                activationRoot = 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 }),
+            yes,
+            json,
+            help
+        };
+    }
     for (let index = 0; index < args.length; index += 1) {
         const arg = args[index];
         if (arg === "--help" || arg === "-h") {
@@ -300,7 +682,23 @@ export function parseOperatorCliArgs(argv) {
             dryRun = true;
             continue;
         }
+        if (arg === "--shared") {
+            shared = true;
+            continue;
+        }
+        if (arg === "--detailed") {
+            detailed = true;
+            continue;
+        }
         const next = args[index + 1];
+        if (arg === "--openclaw-home") {
+            if (next === undefined) {
+                throw new Error("--openclaw-home requires a value");
+            }
+            openclawHome = next;
+            index += 1;
+            continue;
+        }
         if (arg === "--activation-root") {
             if (next === undefined) {
                 throw new Error("--activation-root requires a value");
@@ -400,8 +798,71 @@ export function parseOperatorCliArgs(argv) {
             index += 1;
             continue;
         }
+        if (arg === "--pack-root") {
+            if (next === undefined) {
+                throw new Error("--pack-root requires a value");
+            }
+            packRoot = next;
+            index += 1;
+            continue;
+        }
+        if (arg === "--workspace-id") {
+            if (next === undefined) {
+                throw new Error("--workspace-id requires a value");
+            }
+            workspaceId = next;
+            index += 1;
+            continue;
+        }
         throw new Error(`unknown argument: ${arg}`);
     }
+    if (command === "setup") {
+        if (help) {
+            return { command, openclawHome: "", activationRoot: "", shared: false, workspaceId: "", json, help };
+        }
+        if (openclawHome === null || openclawHome.trim().length === 0) {
+            throw new Error("--openclaw-home is required for setup");
+        }
+        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;
+        return {
+            command,
+            openclawHome: resolvedOpenclawHome,
+            activationRoot: resolvedActivationRoot,
+            shared,
+            workspaceId: resolvedWorkspaceId,
+            json,
+            help
+        };
+    }
+    if (command === "attach") {
+        if (help) {
+            return { command, activationRoot: "", packRoot: "", packLabel: "", workspaceId: "", brainAttachmentPolicy: null, json, help };
+        }
+        if (activationRoot === null || activationRoot.trim().length === 0) {
+            throw new Error("--activation-root is required for attach");
+        }
+        const resolvedActivationRoot = path.resolve(activationRoot);
+        const resolvedPackRoot = packRoot !== null
+            ? path.resolve(packRoot)
+            : path.resolve(resolvedActivationRoot, "packs", "initial");
+        const resolvedWorkspaceId = workspaceId ?? "workspace";
+        const resolvedPackLabel = packLabel ?? "cli-attach";
+        return {
+            command,
+            activationRoot: resolvedActivationRoot,
+            packRoot: resolvedPackRoot,
+            packLabel: resolvedPackLabel,
+            workspaceId: resolvedWorkspaceId,
+            brainAttachmentPolicy: brainAttachmentPolicy,
+            json,
+            help
+        };
+    }
     if (command === "scan") {
         if ((sessionPath === null && livePath === null) || (sessionPath !== null && livePath !== null)) {
             throw new Error("scan requires exactly one of --session or --live");
@@ -436,7 +897,7 @@ export function parseOperatorCliArgs(argv) {
         };
     }
     return {
-        command,
+        command: command,
         input: {
             activationRoot: activationRoot ?? "",
             eventExportPath,
@@ -446,7 +907,8 @@ export function parseOperatorCliArgs(argv) {
         },
         json,
         help,
-        dryRun
+        dryRun,
+        detailed
     };
 }
 function isDirectCliRun(entryArg, moduleUrl) {
@@ -460,12 +922,835 @@ function isDirectCliRun(entryArg, moduleUrl) {
         return pathToFileURL(path.resolve(entryArg)).href === moduleUrl;
     }
 }
+/**
+ * Resolve the path to the pre-built extension template shipped with this package.
+ * Falls back to a generated string if the template file is missing (e.g. in tests).
+ */
+function resolveExtensionTemplatePath() {
+    const candidates = [
+        path.resolve(__dirname, "..", "extension", "index.ts"),
+        path.resolve(__dirname, "..", "..", "extension", "index.ts"),
+    ];
+    for (const candidate of candidates) {
+        if (existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    throw new Error("Pre-built extension template not found. Searched:\n" +
+        candidates.map((c) => `  - ${c}`).join("\n"));
+}
+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() {
+    return JSON.stringify({
+        name: "openclawbrain-extension",
+        version: "0.1.0",
+        private: true,
+        type: "module",
+        dependencies: {
+            "@openclawbrain/openclaw": ">=0.2.0"
+        }
+    }, null, 2) + "\n";
+}
+function buildExtensionPluginManifest() {
+    return JSON.stringify({
+        id: "openclawbrain",
+        name: "OpenClawBrain",
+        description: "Learned memory and context from OpenClawBrain",
+        version: "0.2.0"
+    }, null, 2) + "\n";
+}
+function formatContextForHuman(result) {
+    if (!result.ok) {
+        if (result.fallbackToStaticContext) {
+            return "No learned context yet. Talk to your agent and check back.";
+        }
+        return `Brain error: ${result.error}`;
+    }
+    if (result.brainContext.trim().length === 0) {
+        return "No learned context yet. Talk to your agent and check back.";
+    }
+    return result.brainContext;
+}
+function runContextCommand(parsed) {
+    const result = compileRuntimeContext({
+        activationRoot: parsed.activationRoot,
+        message: parsed.message
+    });
+    if (parsed.json) {
+        console.log(JSON.stringify({
+            ok: result.ok,
+            activationRoot: result.activationRoot,
+            activePackId: result.ok ? result.activePackId : null,
+            brainContext: result.brainContext,
+            fallbackToStaticContext: result.ok ? false : result.fallbackToStaticContext,
+            hardRequirementViolated: result.ok ? false : result.hardRequirementViolated,
+            error: result.ok ? null : result.error
+        }, null, 2));
+    }
+    else {
+        console.log(formatContextForHuman(result));
+    }
+    return 0;
+}
+function formatHistoryTimestamp(iso) {
+    const date = new Date(iso);
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, "0");
+    const day = String(date.getDate()).padStart(2, "0");
+    const hours = String(date.getHours()).padStart(2, "0");
+    const minutes = String(date.getMinutes()).padStart(2, "0");
+    return `${year}-${month}-${day} ${hours}:${minutes}`;
+}
+function loadManifestSafe(manifestPath) {
+    try {
+        if (!existsSync(manifestPath)) {
+            return null;
+        }
+        return JSON.parse(readFileSync(manifestPath, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function buildHistoryEntry(record, slot, isActive) {
+    const manifest = loadManifestSafe(record.manifestPath);
+    const eventCount = record.eventRange.count;
+    // Count corrections from the learning surface in the manifest provenance
+    let correctionCount = 0;
+    if (manifest !== null) {
+        const learningSurface = manifest.provenance?.learningSurface;
+        if (learningSurface?.labelHarvest) {
+            correctionCount = learningSurface.labelHarvest.humanLabels;
+        }
+    }
+    // Determine the label: seed packs have 0 events, promoted packs have events
+    const label = eventCount === 0 ? "seed" : "promoted";
+    return {
+        packId: record.packId,
+        slot,
+        label,
+        builtAt: record.builtAt,
+        updatedAt: record.updatedAt,
+        eventCount,
+        correctionCount,
+        current: isActive
+    };
+}
+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));
+        }
+        else {
+            console.log("No history yet. Run: openclawbrain setup");
+        }
+        return 0;
+    }
+    let pointers;
+    try {
+        pointers = JSON.parse(readFileSync(pointersPath, "utf8"));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`Failed to read activation pointers: ${message}`);
+        return 1;
+    }
+    // Build history entries from pointers: active is most recent, then previous
+    const entries = [];
+    if (pointers.active !== null) {
+        entries.push(buildHistoryEntry(pointers.active, "active", true));
+    }
+    if (pointers.previous !== null) {
+        // Only add if different from active
+        if (pointers.active === null || pointers.previous.packId !== pointers.active.packId) {
+            entries.push(buildHistoryEntry(pointers.previous, "previous", false));
+        }
+    }
+    if (pointers.candidate !== null) {
+        // Only add if different from active and previous
+        const isDuplicate = entries.some((e) => e.packId === pointers.candidate.packId);
+        if (!isDuplicate) {
+            entries.push(buildHistoryEntry(pointers.candidate, "candidate", false));
+        }
+    }
+    if (entries.length === 0) {
+        if (parsed.json) {
+            console.log(JSON.stringify({ entries: [], empty: true, message: "No history yet. Run: openclawbrain setup" }, null, 2));
+        }
+        else {
+            console.log("No history yet. Run: openclawbrain setup");
+        }
+        return 0;
+    }
+    // Sort by updatedAt descending (most recent first)
+    entries.sort((a, b) => Date.parse(b.updatedAt) - Date.parse(a.updatedAt));
+    // Apply limit
+    const limited = entries.slice(0, parsed.limit);
+    if (parsed.json) {
+        console.log(JSON.stringify({
+            entries: limited,
+            activationRoot,
+            empty: false
+        }, null, 2));
+        return 0;
+    }
+    // Human-readable output
+    for (const entry of limited) {
+        const packShort = entry.packId.length > 9 ? entry.packId.slice(0, 9) : entry.packId;
+        const timestamp = formatHistoryTimestamp(entry.updatedAt);
+        const tag = entry.current ? "(current)" : "(previous)";
+        let line = `${packShort.padEnd(10)} ${entry.label.padEnd(10)} ${timestamp}  ${tag}`;
+        // Add stats suffix for promoted packs
+        if (entry.label === "promoted" && (entry.correctionCount > 0 || entry.eventCount > 0)) {
+            const parts = [];
+            if (entry.correctionCount > 0) {
+                parts.push(`${entry.correctionCount} corrections`);
+            }
+            if (entry.eventCount > 0) {
+                parts.push(`${entry.eventCount} events`);
+            }
+            line += ` — ${parts.join(", ")}`;
+        }
+        console.log(line);
+    }
+    return 0;
+}
+function runSetupCommand(parsed) {
+    const steps = [];
+    // 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)) {
+        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 {
+        const packRoot = path.resolve(parsed.activationRoot, "packs", "initial");
+        mkdirSync(packRoot, { recursive: true });
+        const brainAttachmentPolicy = parsed.shared ? "shared" : "dedicated";
+        const result = bootstrapRuntimeAttach({
+            profileSelector: "current_profile",
+            brainAttachmentPolicy,
+            activationRoot: parsed.activationRoot,
+            packRoot,
+            packLabel: "setup-cli",
+            workspace: {
+                workspaceId: parsed.workspaceId,
+                snapshotId: `${parsed.workspaceId}@setup-${new Date().toISOString().slice(0, 10)}`,
+                capturedAt: new Date().toISOString(),
+                rootDir: parsed.openclawHome,
+                revision: "cli-setup-v1"
+            },
+            interactionEvents: [],
+            feedbackEvents: []
+        });
+        steps.push(`Bootstrapped brain attach: ${result.status}`);
+    }
+    // 4-7. Write extension files
+    const extensionDir = path.join(parsed.openclawHome, "extensions", "openclawbrain");
+    mkdirSync(extensionDir, { recursive: true });
+    // 4. 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
+    const packageJsonPath = path.join(extensionDir, "package.json");
+    writeFileSync(packageJsonPath, buildExtensionPackageJson(), "utf8");
+    steps.push(`Wrote package.json: ${packageJsonPath}`);
+    // 6. npm install
+    try {
+        execSync("npm install --ignore-scripts", { cwd: extensionDir, stdio: "pipe" });
+        steps.push("Ran npm install --ignore-scripts");
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        steps.push(`npm install failed (non-fatal): ${message}`);
+    }
+    // 7. Write plugin manifest
+    const manifestPath = path.join(extensionDir, "openclaw.plugin.json");
+    writeFileSync(manifestPath, buildExtensionPluginManifest(), "utf8");
+    steps.push(`Wrote manifest: ${manifestPath}`);
+    // 8. Write BRAIN.md to workspace directories
+    const brainMdContent = [
+        "## OpenClawBrain",
+        `You have a learning brain attached at ${parsed.activationRoot}.`,
+        "- It learns automatically from your conversations",
+        '- Corrections matter — "no, actually X" teaches the brain X',
+        "- You don't manage it — background daemon handles learning",
+        "- Check: `openclawbrain status`",
+        "- Rollback: `openclawbrain rollback`",
+        '- See what brain knows: `openclawbrain context "your question"`',
+        ""
+    ].join("\n");
+    const agentsMdBrainRef = "\n5. Read `BRAIN.md` — your learning brain context\n";
+    try {
+        const entries = readdirSync(parsed.openclawHome, { withFileTypes: true });
+        const workspaceDirs = entries
+            .filter(e => e.isDirectory() && e.name.startsWith("workspace-"))
+            .map(e => path.join(parsed.openclawHome, e.name));
+        // If no workspace-* dirs found, check if openclawHome itself is a workspace
+        if (workspaceDirs.length === 0) {
+            workspaceDirs.push(parsed.openclawHome);
+        }
+        for (const wsDir of workspaceDirs) {
+            const brainMdPath = path.join(wsDir, "BRAIN.md");
+            writeFileSync(brainMdPath, brainMdContent, "utf8");
+            steps.push(`Wrote BRAIN.md: ${brainMdPath}`);
+            // If AGENTS.md exists, append brain reference to startup sequence
+            const agentsMdPath = path.join(wsDir, "AGENTS.md");
+            if (existsSync(agentsMdPath)) {
+                const agentsContent = readFileSync(agentsMdPath, "utf8");
+                if (!agentsContent.includes("BRAIN.md")) {
+                    // Find the startup sequence section and append after the last numbered item
+                    const startupMarker = "## Session Startup";
+                    if (agentsContent.includes(startupMarker)) {
+                        // Find the numbered list in the startup section and append after last item
+                        const lines = agentsContent.split("\n");
+                        let lastNumberedIdx = -1;
+                        let inStartup = false;
+                        for (let i = 0; i < lines.length; i++) {
+                            const line = lines[i] ?? "";
+                            if (line.includes(startupMarker)) {
+                                inStartup = true;
+                                continue;
+                            }
+                            if (inStartup && /^\d+\.\s/.test(line.trim())) {
+                                lastNumberedIdx = i;
+                            }
+                            if (inStartup && line.startsWith("## ") && !line.includes(startupMarker)) {
+                                break;
+                            }
+                        }
+                        if (lastNumberedIdx >= 0) {
+                            lines.splice(lastNumberedIdx + 1, 0, agentsMdBrainRef.trimEnd());
+                            writeFileSync(agentsMdPath, lines.join("\n"), "utf8");
+                            steps.push(`Updated AGENTS.md startup sequence: ${agentsMdPath}`);
+                        }
+                        else {
+                            appendFileSync(agentsMdPath, agentsMdBrainRef, "utf8");
+                            steps.push(`Appended BRAIN.md reference to AGENTS.md: ${agentsMdPath}`);
+                        }
+                    }
+                    else {
+                        appendFileSync(agentsMdPath, agentsMdBrainRef, "utf8");
+                        steps.push(`Appended BRAIN.md reference to AGENTS.md: ${agentsMdPath}`);
+                    }
+                }
+                else {
+                    steps.push(`AGENTS.md already references BRAIN.md: ${agentsMdPath}`);
+                }
+            }
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        steps.push(`BRAIN.md generation failed (non-fatal): ${message}`);
+    }
+    // 9. Print summary
+    if (parsed.json) {
+        console.log(JSON.stringify({
+            command: "setup",
+            openclawHome: parsed.openclawHome,
+            activationRoot: parsed.activationRoot,
+            workspaceId: parsed.workspaceId,
+            shared: parsed.shared,
+            extensionDir,
+            steps
+        }, null, 2));
+    }
+    else {
+        console.log("SETUP 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.");
+    }
+    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;
+    }
+    // 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
+        }));
+    })
+        .sort((left, right) => {
+        if (left.entry.updatedAt !== right.entry.updatedAt) {
+            return left.entry.updatedAt - right.entry.updatedAt;
+        }
+        if (left.store.indexPath !== right.store.indexPath) {
+            return left.store.indexPath.localeCompare(right.store.indexPath);
+        }
+        return left.sessionKey.localeCompare(right.sessionKey);
+    });
+    for (const session of discoveredSessions) {
+        const sessionFile = session.entry.sessionFile;
+        const records = typeof sessionFile !== "string" || sessionFile.trim().length === 0
+            ? []
+            : (() => {
+                try {
+                    return readOpenClawSessionFile(sessionFile);
+                }
+                catch {
+                    return [];
+                }
+            })();
+        const sessionExport = buildPassiveLearningSessionExportFromOpenClawSessionStore({
+            sessionKey: session.sessionKey,
+            indexEntry: session.entry,
+            records,
+            agentId: session.store.agentId,
+            sequenceStart: nextSequence
+        });
+        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;
+    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." }));
+        }
+        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({
+        packLabel: "learn-cli",
+        workspace: {
+            workspaceId: "learn-cli",
+            snapshotId: `learn-cli@${now.slice(0, 10)}`,
+            capturedAt: now,
+            rootDir: activationRoot,
+            revision: "learn-cli-v1"
+        },
+        interactionEvents: allInteractionEvents,
+        feedbackEvents: allFeedbackEvents,
+        learnedRouting: true,
+        state: createAlwaysOnLearningRuntimeState(),
+        builtAt: now
+    });
+    // 4. If materialization produced, materialize → stage → promote
+    if (learnerResult.materialization !== null) {
+        const candidatePackRoot = path.join(activationRoot, "packs", `learn-cli-${Date.now()}`);
+        mkdirSync(candidatePackRoot, { recursive: true });
+        const candidateDescriptor = materializeAlwaysOnLearningCandidatePack(candidatePackRoot, learnerResult.materialization);
+        stageCandidatePack(activationRoot, candidatePackRoot, {
+            updatedAt: now,
+            reason: "learn_cli_stage"
+        });
+        promoteCandidatePack(activationRoot, {
+            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.`);
+        }
+    }
+    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.");
+        }
+    }
+    return 0;
+}
+function formatTimestamp() {
+    const now = new Date();
+    return `[${now.toTimeString().slice(0, 8)}]`;
+}
+function watchLog(message) {
+    console.log(`${formatTimestamp()} ${message}`);
+}
+async function runWatchCommand(parsed) {
+    const activationRoot = parsed.activationRoot;
+    const scanRoot = parsed.scanRoot !== null
+        ? path.resolve(parsed.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 scanner = createRuntimeEventExportScanner({ scanRoot });
+    const teacherLoop = createAsyncTeacherLiveLoop({
+        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"
+        },
+        learnedRouting: true
+    });
+    let stopping = false;
+    const onSignal = () => {
+        if (stopping) {
+            process.exit(1);
+        }
+        stopping = true;
+        watchLog("Stopping... (Ctrl+C again to force)");
+    };
+    process.on("SIGINT", onSignal);
+    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
+                    }));
+                }
+            }
+        }
+        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) => {
+                setTimeout(resolve, Math.min(1000, deadline - Date.now()));
+            });
+        }
+    }
+    watchLog("Watch stopped.");
+    process.removeListener("SIGINT", onSignal);
+    process.removeListener("SIGTERM", onSignal);
+    return 0;
+}
+function promptSyncLine(prompt) {
+    process.stdout.write(prompt);
+    const buf = Buffer.alloc(256);
+    let input = "";
+    const fd = openSync("/dev/tty", "r");
+    try {
+        const bytesRead = readSync(fd, buf, 0, buf.length, null);
+        input = buf.toString("utf8", 0, bytesRead).replace(/\r?\n$/, "");
+    }
+    finally {
+        closeSync(fd);
+    }
+    return input;
+}
+function resetActivationRoot(activationRoot) {
+    const resolvedRoot = path.resolve(activationRoot);
+    const removedPacks = [];
+    const packsDir = path.join(resolvedRoot, "packs");
+    if (existsSync(packsDir)) {
+        try {
+            const entries = readdirSync(packsDir);
+            for (const entry of entries) {
+                const packPath = path.join(packsDir, entry);
+                rmSync(packPath, { recursive: true, force: true });
+                removedPacks.push(entry);
+            }
+        }
+        catch {
+            // packs dir may not be readable
+        }
+    }
+    const logsDir = path.join(resolvedRoot, "logs");
+    if (existsSync(logsDir)) {
+        rmSync(logsDir, { recursive: true, force: true });
+    }
+    const seedPointers = {
+        contract: "activation_pointers.v1",
+        active: null,
+        candidate: null,
+        previous: null
+    };
+    const pointersPath = path.join(resolvedRoot, "activation-pointers.json");
+    mkdirSync(resolvedRoot, { recursive: true });
+    writeFileSync(pointersPath, JSON.stringify(seedPointers, null, 2) + "\n", "utf8");
+    return { removedPacks, pointersReset: true };
+}
+function runResetCommand(parsed) {
+    if (parsed.help) {
+        console.log([
+            "Usage: openclawbrain reset [--activation-root <path>] [--yes] [--json]",
+            "",
+            "Wipes all learned state and returns the brain to seed state.",
+            "",
+            "Options:",
+            "  --activation-root <path>  Activation root (auto-detected if omitted)",
+            "  --yes, -y                 Skip confirmation prompt",
+            "  --json                    Emit machine-readable JSON output",
+            "  --help                    Show this help"
+        ].join("\n"));
+        return 0;
+    }
+    const activationRoot = parsed.activationRoot;
+    if (!existsSync(activationRoot)) {
+        const msg = `Activation root does not exist: ${activationRoot}`;
+        if (parsed.json) {
+            console.log(JSON.stringify({ ok: false, error: msg }, null, 2));
+        }
+        else {
+            console.error(msg);
+        }
+        return 1;
+    }
+    if (!parsed.yes) {
+        let answer;
+        try {
+            answer = promptSyncLine("This will delete all learned context. Type 'reset' to confirm: ");
+        }
+        catch {
+            console.error("Cannot prompt for confirmation in non-interactive mode. Use --yes to skip.");
+            return 1;
+        }
+        if (answer.trim() !== "reset") {
+            console.log("Reset cancelled.");
+            return 1;
+        }
+    }
+    const result = resetActivationRoot(activationRoot);
+    if (parsed.json) {
+        console.log(JSON.stringify({
+            ok: true,
+            activationRoot,
+            removedPacks: result.removedPacks,
+            pointersReset: result.pointersReset
+        }, null, 2));
+    }
+    else {
+        console.log("RESET complete\n");
+        if (result.removedPacks.length > 0) {
+            console.log(`  Removed ${result.removedPacks.length} pack(s): ${result.removedPacks.join(", ")}`);
+        }
+        else {
+            console.log("  No packs to remove.");
+        }
+        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.");
+    }
+    return 0;
+}
 export function runOperatorCli(argv = process.argv.slice(2)) {
     const parsed = parseOperatorCliArgs(argv);
+    if (parsed.command === "context") {
+        return runContextCommand(parsed);
+    }
+    if (parsed.command === "reset") {
+        return runResetCommand(parsed);
+    }
     if (parsed.help) {
         console.log(operatorCliHelp());
         return 0;
     }
+    if (parsed.command === "export") {
+        const result = exportBrain({
+            activationRoot: parsed.activationRoot,
+            outputPath: parsed.outputPath,
+        });
+        if (parsed.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else if (result.ok) {
+            console.log(`EXPORT ok`);
+            console.log(`  Archive: ${result.outputPath}`);
+            console.log(`  Source:  ${result.activationRoot}`);
+        }
+        else {
+            console.error(`EXPORT failed: ${result.error}`);
+        }
+        return result.ok ? 0 : 1;
+    }
+    if (parsed.command === "import") {
+        const result = importBrain({
+            archivePath: parsed.archivePath,
+            activationRoot: parsed.activationRoot,
+            force: parsed.force,
+        });
+        if (parsed.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else if (result.ok) {
+            console.log(`IMPORT ok`);
+            console.log(`  Activation root: ${result.activationRoot}`);
+            console.log(`  Archive:         ${result.archivePath}`);
+            if (result.warning) {
+                console.log(`  Warning:         ${result.warning}`);
+            }
+        }
+        else {
+            console.error(`IMPORT failed: ${result.error}`);
+        }
+        return result.ok ? 0 : 1;
+    }
+    if (parsed.command === "daemon") {
+        return runDaemonCommand(parsed);
+    }
+    if (parsed.command === "history") {
+        return runHistoryCommand(parsed);
+    }
+    if (parsed.command === "learn") {
+        return runLearnCommand(parsed);
+    }
+    if (parsed.command === "watch") {
+        // Watch is async — bridge to sync CLI entry by scheduling and returning 0.
+        // The process stays alive due to the interval loop and exits via SIGINT or error.
+        runWatchCommand(parsed).then((code) => { process.exitCode = code; }, (error) => {
+            console.error("[openclawbrain] watch failed");
+            console.error(error instanceof Error ? error.stack ?? error.message : String(error));
+            process.exitCode = 1;
+        });
+        return 0;
+    }
+    if (parsed.command === "setup") {
+        return runSetupCommand(parsed);
+    }
+    if (parsed.command === "attach") {
+        mkdirSync(parsed.activationRoot, { recursive: true });
+        mkdirSync(parsed.packRoot, { recursive: true });
+        const result = bootstrapRuntimeAttach({
+            profileSelector: "current_profile",
+            ...(parsed.brainAttachmentPolicy != null ? { brainAttachmentPolicy: parsed.brainAttachmentPolicy } : {}),
+            activationRoot: parsed.activationRoot,
+            packRoot: parsed.packRoot,
+            packLabel: parsed.packLabel,
+            workspace: {
+                workspaceId: parsed.workspaceId,
+                snapshotId: `${parsed.workspaceId}@bootstrap-${new Date().toISOString().slice(0, 10)}`,
+                capturedAt: new Date().toISOString(),
+                rootDir: process.cwd(),
+                revision: "cli-bootstrap-v1"
+            },
+            interactionEvents: [],
+            feedbackEvents: []
+        });
+        if (parsed.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            console.log(formatBootstrapRuntimeAttachReport(result));
+        }
+        return 0;
+    }
     if (parsed.command === "scan") {
         if (parsed.sessionPath !== null) {
             const result = scanRecordedSession({
@@ -499,14 +1784,16 @@ export function runOperatorCli(argv = process.argv.slice(2)) {
         }
         return 0;
     }
-    const activationRoot = requireActivationRoot(parsed.input, parsed.command);
-    if (parsed.command === "rollback") {
+    // At this point only status/rollback commands remain
+    const statusOrRollback = parsed;
+    const activationRoot = requireActivationRoot(statusOrRollback.input, statusOrRollback.command);
+    if (statusOrRollback.command === "rollback") {
         const result = rollbackRuntimeAttach({
             activationRoot,
-            ...(parsed.input.updatedAt === null ? {} : { updatedAt: parsed.input.updatedAt }),
-            dryRun: parsed.dryRun
+            ...(statusOrRollback.input.updatedAt === null ? {} : { updatedAt: statusOrRollback.input.updatedAt }),
+            dryRun: statusOrRollback.dryRun
         });
-        if (parsed.json) {
+        if (statusOrRollback.json) {
             console.log(JSON.stringify(result, null, 2));
         }
         else {
@@ -515,18 +1802,23 @@ export function runOperatorCli(argv = process.argv.slice(2)) {
         return result.allowed ? 0 : 1;
     }
     const status = describeCurrentProfileBrainStatus({
-        ...parsed.input,
+        ...statusOrRollback.input,
         activationRoot
     });
-    if (parsed.json) {
+    if (statusOrRollback.json) {
         console.log(JSON.stringify(status, null, 2));
     }
     else {
         const report = buildOperatorSurfaceReport({
-            ...parsed.input,
+            ...statusOrRollback.input,
             activationRoot
         });
-        console.log(formatCurrentProfileStatusSummary(status, report));
+        if (statusOrRollback.detailed) {
+            console.log(formatCurrentProfileStatusSummary(status, report));
+        }
+        else {
+            console.log(formatHumanFriendlyStatus(status, report));
+        }
     }
     return 0;
 }