@openclawbrain/openclaw 0.1.2 → 0.1.4

package/dist/src/index.js

@@ -1,12 +1,13 @@
 import { createHash } from "node:crypto";
-import { mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import process from "node:process";
 import { compileRuntimeFromActivation } from "@openclawbrain/compiler";
 import { CONTRACT_IDS, buildNormalizedEventExport, canonicalJson, checksumJsonPayload, createFeedbackEvent, createInteractionEvent, sortNormalizedEvents, validateKernelSurface, validateNormalizedEventExport } from "@openclawbrain/contracts";
 import { describeNormalizedEventExportObservability } from "@openclawbrain/event-export";
 import { DEFAULT_TEACHER_SUPERVISION_STALE_AFTER_MS, advanceAlwaysOnLearningRuntime, buildTeacherSupervisionArtifactsFromNormalizedEventExport, createAlwaysOnLearningRuntimeState, describeAlwaysOnLearningRuntimeState, materializeAlwaysOnLearningCandidatePack, materializeCandidatePackFromNormalizedEventExport } from "@openclawbrain/learner";
-import { activatePack, describeActivationObservability, describeActivationTarget, describePackCompileTarget, inspectActivationState, promoteCandidatePack, rollbackActivePack, stageCandidatePack } from "@openclawbrain/pack-format";
+import { LEARNING_SPINE_LOG_LAYOUT, activatePack, describeActivationObservability, describeActivationTarget, describePackCompileTarget, inspectActivationState, loadPackFromActivation, promoteCandidatePack, readLearningSpineLogEntries, rollbackActivePack, stageCandidatePack } from "@openclawbrain/pack-format";
+import { appendLearningUpdateLogs, appendServeTimeRouteDecisionLog } from "./learning-spine.js";
 const DEFAULT_AGENT_ID = "openclaw-runtime";
 const FEEDBACK_KINDS = new Set(["correction", "teaching", "approval", "suppression"]);
 export const DEFAULT_ASYNC_TEACHER_QUEUE_CAPACITY = 8;
@@ -20,6 +21,35 @@ export const RUNTIME_EVENT_EXPORT_BUNDLE_LAYOUT = {
     manifest: "manifest.json",
     payload: "normalized-event-export.json"
 };
+function normalizeBrainAttachmentPolicy(value) {
+    if (value === "dedicated" || value === "shared") {
+        return value;
+    }
+    return "undeclared";
+}
+function buildCurrentProfileAttachmentPolicy(policyMode) {
+    if (policyMode === "dedicated") {
+        return {
+            mode: "dedicated",
+            readScope: "current_profile_only",
+            writeScope: "current_profile_only",
+            currentProfileExclusive: true,
+            requiresProfileAttribution: true,
+            detail: "dedicated brains are exclusive to the current profile and must keep profile attribution explicit on every served turn"
+        };
+    }
+    if (policyMode === "shared") {
+        return {
+            mode: "shared",
+            readScope: "attached_profiles",
+            writeScope: "attached_profiles",
+            currentProfileExclusive: false,
+            requiresProfileAttribution: true,
+            detail: "shared brains may serve multiple attached profiles, so status and per-turn attribution must stay profile-explicit"
+        };
+    }
+    return null;
+}
 const OPENCLAW_LANDING_BOUNDARIES_V1 = {
     compileBoundary: {
         contract: CONTRACT_IDS.runtimeCompile,
@@ -994,6 +1024,9 @@ function buildAttachSuccessSignals(input) {
     }
     if (activeTarget !== null) {
         signals.push(`active_workspace_snapshot:${activeTarget.workspaceSnapshot}`);
+        if (activeTarget.eventRange.count === 0) {
+            signals.push("awaiting_first_export");
+        }
     }
     if (input.compile?.ok) {
         signals.push(`compile_ok:${input.compile.activePackId ?? "unknown"}`);
@@ -1079,7 +1112,10 @@ export function rollbackRuntimeAttach(input) {
     }
     const after = dryRun
         ? before.rollback.nextPointers
-        : rollbackActivePack(activationRoot, updatedAt).pointers;
+        : rollbackActivePack(activationRoot, {
+            updatedAt,
+            reason: "runtime_attach_rollback"
+        }).pointers;
     return {
         runtimeOwner: "openclaw",
         activationRoot,
@@ -1108,17 +1144,54 @@ function resolveBootstrapNormalizedEventExport(input) {
         throw new Error("Provide normalizedEventExport or interactionEvents/feedbackEvents, not both");
     }
     const normalizedEventExport = input.normalizedEventExport !== undefined
-        ? structuredClone(input.normalizedEventExport)
+        ? canonicalizeBootstrapNormalizedEventExport(input.normalizedEventExport)
         : buildNormalizedEventExport({
             interactionEvents,
             feedbackEvents
         });
     const validationErrors = validateNormalizedEventExport(normalizedEventExport);
     if (validationErrors.length > 0) {
-        throw new Error(`normalized event export is invalid: ${validationErrors.join("; ")}`);
+        throw new Error(formatBootstrapNormalizedEventExportValidationError(normalizedEventExport, validationErrors));
     }
     return normalizedEventExport;
 }
+function canonicalizeBootstrapNormalizedEventExport(normalizedEventExport) {
+    const interactionEvents = cloneBootstrapNormalizedEventArray(normalizedEventExport.interactionEvents, "interactionEvents");
+    const feedbackEvents = cloneBootstrapNormalizedEventArray(normalizedEventExport.feedbackEvents, "feedbackEvents");
+    try {
+        return buildNormalizedEventExport({
+            interactionEvents,
+            feedbackEvents
+        });
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new Error("bootstrapRuntimeAttach could not reconstruct a safe normalized event export from the provided event arrays. " +
+            "Repair the event payload or, for a first attach with no live events yet, pass empty arrays so bootstrap can self-boot. " +
+            `Details: ${detail}`);
+    }
+}
+function cloneBootstrapNormalizedEventArray(value, fieldName) {
+    if (!Array.isArray(value)) {
+        throw new Error(`bootstrapRuntimeAttach expected normalizedEventExport.${fieldName} to be an array. ` +
+            "For a first attach with no live events yet, pass empty arrays or omit normalizedEventExport and use interactionEvents: [] / feedbackEvents: [].");
+    }
+    return structuredClone(value);
+}
+function formatBootstrapNormalizedEventExportValidationError(normalizedEventExport, validationErrors) {
+    const details = validationErrors.join("; ");
+    const zeroEventBootstrap = normalizedEventExport.interactionEvents.length === 0 &&
+        normalizedEventExport.feedbackEvents.length === 0 &&
+        normalizedEventExport.range.count === 0;
+    if (zeroEventBootstrap) {
+        return ("bootstrapRuntimeAttach could not derive a safe zero-event bootstrap export: " +
+            `${details}. ` +
+            "For a first attach with no live events yet, pass empty interaction/feedback arrays or an empty normalized export payload and bootstrap will self-boot.");
+    }
+    return ("bootstrapRuntimeAttach could not use the provided normalized event export: " +
+        `${details}. ` +
+        "Repair the event payload or pass raw interactionEvents/feedbackEvents so bootstrap can derive range and provenance itself.");
+}
 export function bootstrapRuntimeAttach(input) {
     const activationRoot = path.resolve(normalizeNonEmptyString(input.activationRoot, "activationRoot"));
     const packRoot = path.resolve(normalizeNonEmptyString(input.packRoot, "packRoot"));
@@ -1141,7 +1214,10 @@ export function bootstrapRuntimeAttach(input) {
         ...(input.structuralOps !== undefined ? { structuralOps: input.structuralOps } : {}),
         ...(input.sparseFeedback !== undefined ? { sparseFeedback: input.sparseFeedback } : {})
     });
-    activatePack(activationRoot, packRoot, activatedAt);
+    activatePack(activationRoot, packRoot, {
+        updatedAt: activatedAt,
+        reason: "attach_bootstrap"
+    });
     return {
         runtimeOwner: "openclaw",
         activationRoot,
@@ -1154,6 +1230,48 @@ export function bootstrapRuntimeAttach(input) {
         })
     };
 }
+function buildRuntimeTurnAttribution(input) {
+    const brainAttachmentPolicy = normalizeBrainAttachmentPolicy(input.turn.brainAttachmentPolicy);
+    if (input.compileResult.ok) {
+        const notes = input.compileResult.compileResponse.diagnostics.notes;
+        const contextAttribution = buildContextAttributionSummary({
+            fallbackToStaticContext: false,
+            hardRequirementViolated: false,
+            usedLearnedRouteFn: input.compileResult.compileResponse.diagnostics.usedLearnedRouteFn,
+            selectedContext: input.compileResult.compileResponse.selectedContext,
+            notes
+        });
+        return {
+            hostRuntimeOwner: "openclaw",
+            profileSelector: "current_profile",
+            brainAttachmentPolicy,
+            brainStatus: "serving_active_pack",
+            activePackId: input.compileResult.activePackId,
+            usedLearnedRouteFn: input.compileResult.compileResponse.diagnostics.usedLearnedRouteFn,
+            routerIdentity: input.compileResult.compileResponse.diagnostics.routerIdentity,
+            selectionDigest: input.compileResult.compileResponse.diagnostics.selectionDigest,
+            selectionTiers: readDiagnosticNoteValue(notes, "selection_tiers="),
+            contextEvidence: contextAttribution.evidence === "unprobed" ? null : contextAttribution.evidence
+        };
+    }
+    const contextAttribution = buildContextAttributionSummary({
+        fallbackToStaticContext: input.compileResult.fallbackToStaticContext,
+        hardRequirementViolated: input.compileResult.hardRequirementViolated,
+        usedLearnedRouteFn: null
+    });
+    return {
+        hostRuntimeOwner: "openclaw",
+        profileSelector: "current_profile",
+        brainAttachmentPolicy,
+        brainStatus: input.compileResult.hardRequirementViolated ? "hard_fail" : "fail_open_static_context",
+        activePackId: null,
+        usedLearnedRouteFn: null,
+        routerIdentity: null,
+        selectionDigest: null,
+        selectionTiers: null,
+        contextEvidence: contextAttribution.evidence === "unprobed" ? null : contextAttribution.evidence
+    };
+}
 function buildCompileInteractionEvent(input) {
     if (!input.compileResult.ok) {
         return null;
@@ -1168,6 +1286,10 @@ function buildCompileInteractionEvent(input) {
         sessionId: input.turn.sessionId,
         source: input.sourceStream
     });
+    const attribution = buildRuntimeTurnAttribution({
+        turn: input.turn,
+        compileResult: input.compileResult
+    });
     return createInteractionEvent({
         eventId,
         agentId: input.agentId,
@@ -1180,7 +1302,8 @@ function buildCompileInteractionEvent(input) {
             runtimeOwner: "openclaw",
             stream: input.sourceStream
         },
-        packId: input.compileResult.compileResponse.packId
+        packId: input.compileResult.compileResponse.packId,
+        attribution
     });
 }
 function buildDeliveryInteractionEvent(input) {
@@ -1201,6 +1324,10 @@ function buildDeliveryInteractionEvent(input) {
         sessionId: input.turn.sessionId,
         source: input.sourceStream
     });
+    const attribution = buildRuntimeTurnAttribution({
+        turn: input.turn,
+        compileResult: input.compileResult
+    });
     return createInteractionEvent({
         eventId,
         agentId: input.agentId,
@@ -1213,12 +1340,17 @@ function buildDeliveryInteractionEvent(input) {
             runtimeOwner: "openclaw",
             stream: input.sourceStream
         },
+        attribution,
         ...(input.compileResult.ok ? { packId: input.compileResult.compileResponse.packId } : {}),
         ...(messageId !== undefined ? { messageId } : {})
     });
 }
 function buildFeedbackEvents(input) {
     const feedbackItems = input.turn.feedback ?? [];
+    const attribution = buildRuntimeTurnAttribution({
+        turn: input.turn,
+        compileResult: input.compileResult
+    });
     return feedbackItems.map((item, index) => {
         if (item === null) {
             throw new Error(`feedback[${index}] must be an object`);
@@ -1255,6 +1387,7 @@ function buildFeedbackEvents(input) {
                 stream: input.sourceStream
             },
             content,
+            attribution,
             ...(messageId !== undefined ? { messageId } : {}),
             ...(relatedInteractionId !== undefined ? { relatedInteractionId } : {})
         });
@@ -1287,6 +1420,7 @@ export function buildNormalizedRuntimeEventExport(turn, compileResult) {
         nextSequence,
         defaultCreatedAt: compileCreatedAt,
         compileInteraction,
+        compileResult,
         agentId
     });
     const deliveryInteraction = buildDeliveryInteractionEvent({
@@ -1357,12 +1491,36 @@ export function runRuntimeTurn(turn, options = {}) {
         ...(turn.runtimeHints !== undefined ? { runtimeHints: turn.runtimeHints } : {})
     };
     const compileResult = compileRuntimeContext(compileInput);
+    const warnings = [];
+    const serveLoggedAt = turn.compile?.createdAt ?? turn.createdAt ?? new Date().toISOString();
     if (!compileResult.ok && compileResult.hardRequirementViolated) {
+        try {
+            appendServeTimeRouteDecisionLog({
+                activationRoot: compileInput.activationRoot,
+                turn,
+                compileResult,
+                recordedAt: serveLoggedAt
+            });
+        }
+        catch {
+        }
         throw new Error(compileResult.error);
     }
-    const warnings = [];
     try {
         const normalizedEventExport = buildNormalizedRuntimeEventExport(turn, compileResult);
+        try {
+            const compileEvent = normalizedEventExport.interactionEvents.find((event) => event.kind === "memory_compiled");
+            appendServeTimeRouteDecisionLog({
+                activationRoot: compileInput.activationRoot,
+                turn,
+                compileResult,
+                normalizedEventExport,
+                recordedAt: compileEvent?.createdAt ?? serveLoggedAt
+            });
+        }
+        catch (error) {
+            warnings.push(`learning spine serve log failed: ${toErrorMessage(error)}`);
+        }
         const eventExport = writeRuntimeEventExportBundle(turn, normalizedEventExport);
         return {
             ...compileResult,
@@ -1442,6 +1600,13 @@ export function runContinuousProductLoopTurn(input) {
     currentState.interactionEvents = mergedHistory.interactionEvents;
     currentState.feedbackEvents = mergedHistory.feedbackEvents;
     try {
+        let activeBeforePack = null;
+        try {
+            activeBeforePack = loadPackFromActivation(activationRoot, "active", { requireActivationReady: true });
+        }
+        catch {
+            activeBeforePack = null;
+        }
         const learnerResult = advanceAlwaysOnLearningRuntime({
             packLabel: input.packLabel,
             workspace: input.workspace,
@@ -1474,13 +1639,30 @@ export function runContinuousProductLoopTurn(input) {
             learning.candidatePack = cloneContinuousProductLoopPackVersion(candidatePack);
             currentState.candidatePack = cloneContinuousProductLoopPackVersion(candidatePack);
             const stagedAt = normalizeIsoTimestamp(input.stageUpdatedAt, "stageUpdatedAt", descriptor.manifest.provenance.builtAt);
-            stageCandidatePack(activationRoot, candidateRootDir, stagedAt);
+            try {
+                appendLearningUpdateLogs({
+                    activationRoot,
+                    materialization: learnerResult.materialization,
+                    activeBeforePack,
+                    candidateDescriptor: descriptor
+                });
+            }
+            catch (error) {
+                learningWarnings.push(`learning spine update logs failed: ${toErrorMessage(error)}`);
+            }
+            stageCandidatePack(activationRoot, candidateRootDir, {
+                updatedAt: stagedAt,
+                reason: `stage_candidate:${learnerResult.materialization.reason}:${learnerResult.materialization.lane}`
+            });
             const stagedInspection = inspectActivationState(activationRoot, stagedAt);
             learning.promotionAllowed = stagedInspection.promotion.allowed;
             learning.promotionFindings = [...stagedInspection.promotion.findings];
             if ((input.autoPromote ?? true) && stagedInspection.promotion.allowed) {
                 const promotedAt = normalizeIsoTimestamp(input.promoteUpdatedAt, "promoteUpdatedAt", stagedAt);
-                promoteCandidatePack(activationRoot, promotedAt);
+                promoteCandidatePack(activationRoot, {
+                    updatedAt: promotedAt,
+                    reason: `auto_promote:${learnerResult.materialization.reason}:${learnerResult.materialization.lane}`
+                });
                 currentState.promotionCount += 1;
                 currentState.candidatePack = null;
                 learning.promoted = true;
@@ -1896,7 +2078,10 @@ function prepareSeedActivation(rootDir, fixture) {
             connect: 1
         }
     });
-    activatePack(activationRoot, seedPackRoot, fixture.seedActivatedAt);
+    activatePack(activationRoot, seedPackRoot, {
+        updatedAt: fixture.seedActivatedAt,
+        reason: "recorded_session_seed_activate"
+    });
     return {
         activationRoot,
         seedPackId: seedPack.manifest.packId
@@ -2056,6 +2241,146 @@ export function verifyRecordedSessionReplayBundleHashes(bundle) {
         scoreHashMatches: rescored.scoreHash === bundle.scoreHash
     };
 }
+export const OPERATOR_API_CONTRACT_ID = "openclaw_operator_api.v1";
+export const SUPPORTED_OPERATOR_API_FAMILIES = [
+    "bootstrap_attach",
+    "status",
+    "export",
+    "refresh",
+    "promote",
+    "rollback",
+    "proof_observability"
+];
+export const OPERATOR_API_CONTRACT_V1 = {
+    contract: OPERATOR_API_CONTRACT_ID,
+    runtimeOwner: "openclaw",
+    scope: "narrow_supported_operator_surface",
+    families: SUPPORTED_OPERATOR_API_FAMILIES,
+    routes: [
+        {
+            family: "bootstrap_attach",
+            scope: "programmatic",
+            packageName: "@openclawbrain/openclaw",
+            entrypoints: ["bootstrapRuntimeAttach", "describeAttachStatus"],
+            summary: "Bootstrap the first attach pack and prove the initial handoff state without pretending live learning has already run.",
+            notes: [
+                "Zero-event bootstrap is supported and stays explicit through awaiting_first_export.",
+                "Attach serves only from activation's active slot after bootstrap completes."
+            ]
+        },
+        {
+            family: "status",
+            scope: "cli",
+            packageName: "@openclawbrain/openclaw",
+            entrypoints: ["openclawbrain-ops status", "describeCurrentProfileBrainStatus"],
+            summary: "Read the canonical current-profile brain-status object for the active Host/Profile/Brain/Attachment boundary.",
+            notes: [
+                "Status is the first operator read path.",
+                "describeCurrentProfileBrainStatus() freezes the supported Host/Profile/Brain/Attachment answer shape for the current profile.",
+                "Use activation and export observability proof helpers when you need candidate/previous or export-freshness detail."
+            ]
+        },
+        {
+            family: "export",
+            scope: "programmatic",
+            packageName: "@openclawbrain/openclaw",
+            entrypoints: ["buildNormalizedRuntimeEventExport", "writeRuntimeEventExportBundle", "loadRuntimeEventExportBundle"],
+            summary: "Emit the deterministic learner handoff artifact explicitly instead of folding export into a larger implicit runtime loop.",
+            notes: [
+                "Export is an off-hot-path operator handoff artifact, not proof of immediate active-pack mutation.",
+                "Bundle roots and normalized payloads are both accepted downstream by observability surfaces."
+            ]
+        },
+        {
+            family: "refresh",
+            scope: "programmatic",
+            packageName: "@openclawbrain/learner",
+            entrypoints: [
+                "createAlwaysOnLearningRuntimeState",
+                "advanceAlwaysOnLearningRuntime",
+                "materializeAlwaysOnLearningCandidatePack"
+            ],
+            summary: "Refresh candidate learning state explicitly through the learner boundary before any activation-pointer move happens.",
+            notes: [
+                "Refresh is PG-only candidate-pack materialization in this repo.",
+                "Refresh does not mutate the currently served active pack in place."
+            ]
+        },
+        {
+            family: "promote",
+            scope: "programmatic",
+            packageName: "@openclawbrain/pack-format",
+            entrypoints: ["stageCandidatePack", "promoteCandidatePack"],
+            summary: "Stage and promote activation-ready candidate packs through explicit pointer changes.",
+            notes: [
+                "Promotion is the only path that changes which pack is served.",
+                "Candidate and previous remain inspectable around the pointer move."
+            ]
+        },
+        {
+            family: "rollback",
+            scope: "cli",
+            packageName: "@openclawbrain/openclaw",
+            entrypoints: ["openclawbrain-ops rollback", "rollbackRuntimeAttach", "formatOperatorRollbackReport"],
+            summary: "Preview and apply the explicit active<-previous / active->candidate rollback move.",
+            notes: [
+                "Rollback is blocked when the previous pointer is unavailable.",
+                "Dry-run is the required first read path for safe operator rollback."
+            ]
+        },
+        {
+            family: "proof_observability",
+            scope: "programmatic",
+            packageName: "@openclawbrain/openclaw",
+            entrypoints: ["describeAttachStatus", "describeKernelBrainBoundary"],
+            summary: "Prove the local attach and kernel-vs-brain boundary from the shipped bridge surface.",
+            notes: [
+                "Use these for repo-local or installed-package operator proof reads.",
+                "These surfaces report the promoted artifact boundary, not full live runtime plasticity."
+            ]
+        },
+        {
+            family: "proof_observability",
+            scope: "programmatic",
+            packageName: "@openclawbrain/pack-format",
+            entrypoints: ["describeActivationObservability"],
+            summary: "Inspect activation health, freshness, route artifacts, rollback lineage, and slot readiness.",
+            notes: ["Activation observability is the ground truth for active/candidate/previous slot inspection."]
+        },
+        {
+            family: "proof_observability",
+            scope: "programmatic",
+            packageName: "@openclawbrain/event-export",
+            entrypoints: ["describeNormalizedEventExportObservability"],
+            summary: "Inspect supervision freshness and teacher freshness from the exported learner handoff artifact.",
+            notes: ["Export observability is local-to-export proof only."]
+        },
+        {
+            family: "proof_observability",
+            scope: "proof_lane",
+            packageName: "workspace",
+            entrypoints: ["pnpm current-profile-lifecycle:smoke", "pnpm observability:smoke"],
+            summary: "Run the repo-local proof lanes that derive operator truth from the canonical current-profile status object plus activation observability.",
+            notes: ["These lanes are proof machinery, not a second semver-stable API."]
+        }
+    ],
+    quarantinedSurface: [
+        "openclawbrain-ops doctor was deleted; use the canonical current-profile status object plus proof helpers instead of a parallel troubleshooting surface.",
+        "buildOperatorSurfaceReport / formatOperatorStatusReport / formatOperatorDoctorReport were historical parallel status surfaces and are not the supported operator API.",
+        "runContinuousProductLoopTurn collapses export/refresh/promote into one proof helper and is not the supported operator API.",
+        "runRecordedSessionReplay and recorded-session fixtures are proof helpers, not operator API.",
+        "release scripts, root smoke plumbing, and workspace layout are proof-and-build machinery, not operator API.",
+        "runRuntimeTurn is a runtime convenience wrapper and not the narrow operator export contract.",
+        "createAsyncTeacherLiveLoop is supporting internals for refresh/teacher snapshots, not the narrow operator contract."
+    ]
+};
+export const OPENCLAW_OPERATOR_NOUNS_V1 = ["Host", "Profile", "Brain", "Attachment"];
+export const CURRENT_PROFILE_BRAIN_STATUS_CONTRACT = CONTRACT_IDS.currentProfileBrainStatus;
+export const BRAIN_ATTACHMENT_POLICY_SEMANTICS_V1 = {
+    undeclared: "The Host has not declared whether the current Profile's Brain attachment policy is shared or dedicated; do not infer profile exclusivity from activation state alone.",
+    dedicated: "The Host declares a dedicated Brain attachment policy: one Profile is intentionally attached to one Brain activation root, and operators may treat the served Brain state as profile-specific until the attachment changes.",
+    shared: "The Host declares a shared Brain attachment policy: multiple Profiles may intentionally attach to the same Brain activation root, attribution must stay current-profile explicit, and operators must not treat later served context as profile-exclusive."
+};
 function summarizeOperatorSlot(slot, updatedAt) {
     if (slot === null) {
         return null;
@@ -2108,6 +2433,9 @@ function summarizeCandidateAheadBy(candidateAheadBy) {
         .map(([field]) => field)
         .sort();
 }
+function isAwaitingFirstExportSlot(slot) {
+    return slot !== null && slot.eventRange.count === 0;
+}
 function summarizeBrainState(active, observability) {
     if (active === null) {
         return {
@@ -2202,7 +2530,8 @@ function loadOperatorEventExport(input) {
         return {
             sourcePath: resolvedPath,
             sourceKind: "bundle_root",
-            normalizedEventExport: bundle.normalizedEventExport
+            normalizedEventExport: bundle.normalizedEventExport,
+            exportedAt: bundle.manifest.exportedAt
         };
     }
     const normalizedEventExport = readJsonFile(resolvedPath);
@@ -2213,7 +2542,8 @@ function loadOperatorEventExport(input) {
     return {
         sourcePath: resolvedPath,
         sourceKind: "payload",
-        normalizedEventExport
+        normalizedEventExport,
+        exportedAt: null
     };
 }
 function summarizeSupervision(input) {
@@ -2224,6 +2554,7 @@ function summarizeSupervision(input) {
             sourcePath: null,
             sourceKind: "missing",
             exportDigest: null,
+            exportedAt: null,
             flowing: null,
             sourceCount: 0,
             freshestSourceStream: null,
@@ -2242,6 +2573,7 @@ function summarizeSupervision(input) {
         sourcePath: loaded.sourcePath,
         sourceKind: loaded.sourceKind,
         exportDigest: observability.exportDigest,
+        exportedAt: loaded.exportedAt,
         flowing,
         sourceCount: observability.supervisionFreshnessBySource.length,
         freshestSourceStream: observability.teacherFreshness.sourceStream ?? freshestSource?.sourceStream ?? null,
@@ -2390,13 +2722,16 @@ function buildOperatorFindings(report) {
         findings.push({ severity, code, summary, detail });
     };
     if (report.active === null) {
-        push("fail", "active_missing", "active slot is empty", "activate a healthy pack before serving or troubleshooting promotions");
+        push("fail", "active_missing", "active slot is empty", "no active pack found; this is the pre-bootstrap state — call `bootstrapRuntimeAttach()` to activate an initial pack before compiling or serving");
     }
     else if (!report.active.activationReady) {
         push("fail", "active_unhealthy", `active slot is not activation-ready: ${report.active.packId}`, report.active.findings.join("; ") || "inspect the active pack payloads and activation pointers");
     }
     else {
         push("pass", "active_ready", `active slot is ready: ${report.active.packId}`, "serving can inspect the active pack without activation drift");
+        if (isAwaitingFirstExportSlot(report.active)) {
+            push("warn", "bootstrap_waiting_for_first_export", "active pack bootstrapped without live exports yet", "serving is up from seed-state defaults; this is expected on first install — learning activates after the first turn is captured via `runRuntimeTurn()`");
+        }
     }
     if (report.learnedRouting.required) {
         if (report.learnedRouting.available) {
@@ -2506,7 +2841,139 @@ function formatCompactValue(value, empty = "none", maxLength = 24) {
     }
     return value.length <= maxLength ? value : `${value.slice(0, maxLength)}…`;
 }
-export function buildOperatorSurfaceReport(input) {
+function summarizeCurrentProfileLogRoot(activationRoot) {
+    const logRoot = path.join(path.resolve(activationRoot), LEARNING_SPINE_LOG_LAYOUT.dir);
+    return existsSync(logRoot) ? logRoot : null;
+}
+function summarizeCurrentProfileLastLearningUpdateAt(activationRoot, learning) {
+    const updates = readLearningSpineLogEntries(activationRoot, "pgRouteUpdates");
+    return updates.at(-1)?.recordedAt ?? learning.lastMaterializedAt ?? null;
+}
+function summarizeCurrentProfileBrainSummary(input) {
+    if (!input.attached) {
+        return "Brain is not attached to the current Profile.";
+    }
+    if (input.serveState === "fail_open_static_context") {
+        return "Brain is attached but would fail open to static context.";
+    }
+    if (input.serveState === "hard_fail") {
+        return "Brain is attached but currently hard-fails learned routing.";
+    }
+    if (input.awaitingFirstExport) {
+        return "Brain is serving the seed-state pack and awaiting the first export.";
+    }
+    if (input.brainState === "pg_promoted_pack_authoritative") {
+        return "Brain is serving the promoted pack.";
+    }
+    if (input.serveState === "serving_active_pack") {
+        return "Brain is serving the active pack with learned routing.";
+    }
+    return "Brain is attached but has not been compile-probed yet.";
+}
+function summarizeCurrentProfileBrainStatusLevel(input) {
+    if (!input.attached) {
+        return "fail";
+    }
+    if (input.serveState === "fail_open_static_context" || input.serveState === "hard_fail") {
+        return "fail";
+    }
+    if (input.awaitingFirstExport || input.serveState === "unprobed") {
+        return "warn";
+    }
+    return input.routeFreshness === "updated" ? "ok" : "warn";
+}
+function buildCurrentProfileBrainStatusFromReport(report, policyMode) {
+    const attached = report.active !== null;
+    const awaitingFirstExport = isAwaitingFirstExportSlot(report.active);
+    const routerIdentity = report.servePath.routerIdentity ?? report.learnedRouting.routerIdentity ?? report.active?.routerIdentity ?? null;
+    const routeFreshness = report.servePath.refreshStatus === "updated" || report.servePath.refreshStatus === "no_supervision"
+        ? report.servePath.refreshStatus
+        : "unknown";
+    const activePackId = report.brain.activePackId ?? report.servePath.activePackId ?? report.active?.packId ?? null;
+    const status = summarizeCurrentProfileBrainStatusLevel({
+        attached,
+        serveState: report.servePath.state,
+        routeFreshness,
+        awaitingFirstExport
+    });
+    return {
+        contract: CURRENT_PROFILE_BRAIN_STATUS_CONTRACT,
+        generatedAt: report.generatedAt,
+        host: {
+            noun: "Host",
+            runtimeOwner: "openclaw",
+            activationRoot: report.activationRoot
+        },
+        profile: {
+            noun: "Profile",
+            selector: "current_profile",
+            detail: attached
+                ? "The Host resolves the current Profile through the active Attachment boundary only."
+                : "The current Profile has no active Brain attachment visible at the Host boundary."
+        },
+        brain: {
+            noun: "Brain",
+            activationRoot: attached ? report.activationRoot : null,
+            logRoot: summarizeCurrentProfileLogRoot(report.activationRoot),
+            activePackId,
+            initMode: report.learnedRouting.initMode,
+            state: report.brain.state,
+            routeFreshness,
+            routerIdentity,
+            routerChecksum: report.learnedRouting.routerChecksum,
+            lastExportAt: report.supervision.exportedAt,
+            lastLearningUpdateAt: summarizeCurrentProfileLastLearningUpdateAt(report.activationRoot, report.learning),
+            lastPromotionAt: report.promotion.lastPromotion.at,
+            summary: summarizeCurrentProfileBrainSummary({
+                attached,
+                serveState: report.servePath.state,
+                brainState: report.brain.state,
+                awaitingFirstExport
+            }),
+            detail: report.brain.detail
+        },
+        attachment: attached
+            ? {
+                noun: "Attachment",
+                state: "attached",
+                activationRoot: report.activationRoot,
+                servingSlot: "active",
+                policyMode,
+                policy: buildCurrentProfileAttachmentPolicy(policyMode),
+                detail: policyMode === "shared"
+                    ? "current profile is attached to a shared OpenClawBrain activation boundary"
+                    : policyMode === "dedicated"
+                        ? "current profile is attached to a dedicated OpenClawBrain activation boundary"
+                        : "current profile is attached to an OpenClawBrain activation boundary, but shared-vs-dedicated policy has not been declared"
+            }
+            : {
+                noun: "Attachment",
+                state: "not_attached",
+                activationRoot: null,
+                servingSlot: "none",
+                policyMode,
+                policy: buildCurrentProfileAttachmentPolicy(policyMode),
+                detail: "current profile is not attached to an OpenClawBrain activation boundary"
+            },
+        brainStatus: {
+            status,
+            brainState: report.brain.state,
+            serveState: report.servePath.state,
+            usedLearnedRouteFn: report.servePath.usedLearnedRouteFn,
+            failOpen: report.servePath.fallbackToStaticContext,
+            awaitingFirstExport,
+            detail: report.servePath.state === "serving_active_pack"
+                ? "current profile is serving compiled context from the active promoted pack"
+                : report.servePath.state === "fail_open_static_context"
+                    ? "current profile would fail open to static context because no serving pack is available"
+                    : report.servePath.state === "hard_fail"
+                        ? "current profile cannot serve because the learned-route or activation requirement hard-failed"
+                        : "current profile serve state has not been compile-probed yet"
+        },
+        currentTurnAttribution: null
+    };
+}
+function buildOperatorSurfaceReport(input) {
     const activationRoot = path.resolve(normalizeNonEmptyString(input.activationRoot, "activationRoot"));
     const updatedAt = normalizeIsoTimestamp(input.updatedAt, "updatedAt", new Date().toISOString());
     const inspection = inspectActivationState(activationRoot, updatedAt);
@@ -2535,6 +3002,7 @@ export function buildOperatorSurfaceReport(input) {
             routerTrainedAt: observability.learnedRouteFn.routerTrainedAt,
             objective: observability.learnedRouteFn.objective,
             pgProfile: observability.learnedRouteFn.pgProfile,
+            routerChecksum: observability.learnedRouteFn.routerChecksum,
             objectiveChecksum: observability.learnedRouteFn.objectiveChecksum,
             updateMechanism: observability.learnedRouteFn.updateMechanism,
             updateVersion: observability.learnedRouteFn.updateVersion,
@@ -2572,11 +3040,9 @@ export function buildOperatorSurfaceReport(input) {
         findings
     };
 }
-function formatSlot(label, slot) {
-    if (slot === null) {
-        return `${label.padEnd(11)}pack=none ready=no`;
-    }
-    return `${label.padEnd(11)}pack=${slot.packId} ready=${yesNo(slot.activationReady)} route=${slot.routePolicy} snapshot=${slot.workspaceSnapshot} export=${formatCompactValue(slot.eventExportDigest)} range=${slot.eventRange.start}-${slot.eventRange.end}/${slot.eventRange.count} built=${slot.builtAt} updated=${slot.updatedAt ?? "unknown"}`;
+export function describeCurrentProfileBrainStatus(input) {
+    const report = buildOperatorSurfaceReport(input);
+    return buildCurrentProfileBrainStatusFromReport(report, normalizeBrainAttachmentPolicy(input.brainAttachmentPolicy));
 }
 export function formatOperatorRollbackReport(result) {
     const header = result.allowed ? (result.dryRun ? "ROLLBACK ready" : "ROLLBACK ok") : "ROLLBACK blocked";
@@ -2589,94 +3055,6 @@ export function formatOperatorRollbackReport(result) {
         `findings    ${formatList(result.findings)}`
     ].join("\n");
 }
-export function formatOperatorStatusReport(report) {
-    return [
-        `STATUS ${report.status}`,
-        formatSlot("active", report.active),
-        formatSlot("candidate", report.candidate),
-        `freshness   candidateAhead=${yesNo(report.freshness.activeBehindPromotionReadyCandidate)} delta=${formatList(report.freshness.candidateAheadBy)} lastPromotion=${report.promotion.lastPromotion.known ? report.promotion.lastPromotion.at : report.promotion.lastPromotion.confidence}`,
-        `brain       state=${report.brain.state} init=${report.brain.initMode ?? "unknown"} plasticity=${report.brain.runtimePlasticitySource ?? "unknown"} seedVisible=${yesNo(report.brain.seedStateVisible)} seedBlocks=${report.brain.seedBlockCount}`,
-        `serve       pack=${report.servePath.activePackId ?? report.active?.packId ?? "none"} state=${report.servePath.state} failOpen=${yesNo(report.servePath.fallbackToStaticContext)} hardFail=${yesNo(report.servePath.hardRequirementViolated)} usedRouteFn=${yesNo(report.servePath.usedLearnedRouteFn)} selection=${report.servePath.selectionMode ?? "unknown"} tiers=${report.servePath.contextAttribution.selectionTiers ?? "unknown"}`,
-        `context     kernel=${report.servePath.contextAttribution.stableKernelBlockCount} brain=${report.servePath.contextAttribution.brainCompiledBlockCount} evidence=${report.servePath.contextAttribution.evidence} kernelSrc=${formatCompactList(report.servePath.contextAttribution.stableKernelSources)} brainSrc=${formatCompactList(report.servePath.contextAttribution.brainCompiledSources)}`,
-        `route       router=${report.servePath.routerIdentity ?? report.learnedRouting.routerIdentity ?? "none"} refresh=${report.servePath.refreshStatus ?? "unknown"} freshness=${formatCompactValue(report.servePath.freshnessChecksum ?? report.learnedRouting.freshnessChecksum)} objective=${formatCompactValue(report.learnedRouting.objectiveChecksum)} labels=${report.learnedRouting.collectedLabelsTotal ?? 0} updates=${report.learnedRouting.updateCount ?? 0}`,
-        `supervision flowing=${yesNo(report.supervision.flowing)} source=${report.supervision.freshestSourceStream ?? "none"} freshest=${report.supervision.freshestCreatedAt ?? "unknown"} humanLabels=${report.supervision.humanLabelCount ?? 0} export=${report.supervision.exportDigest ?? "none"}`,
-        `learning    mode=${report.learning.mode} next=${report.learning.nextPriorityLane} pendingLive=${report.learning.pendingLive ?? 0} pendingBackfill=${report.learning.pendingBackfill ?? 0} activeBuilt=${report.active?.builtAt ?? "unknown"} supervisionFreshest=${report.supervision.freshestCreatedAt ?? "unknown"} teacher=${report.teacherLoop.latestFreshness} lastNoOp=${report.teacherLoop.lastNoOpReason} lastProcessed=${report.teacherLoop.lastProcessedAt ?? "unknown"} materialized=${report.teacherLoop.lastMaterializedPackId ?? "none"}`,
-        `rollback    ready=${yesNo(report.rollback.allowed)} previous=${report.rollback.previousPackId ?? "none"} findings=${formatList(report.rollback.findings)}`
-    ].join("\n");
-}
-function orderedDoctorFindings(findings) {
-    const severityOrder = {
-        fail: 0,
-        warn: 1,
-        pass: 2
-    };
-    return [...findings].sort((left, right) => {
-        if (severityOrder[left.severity] !== severityOrder[right.severity]) {
-            return severityOrder[left.severity] - severityOrder[right.severity];
-        }
-        return left.code.localeCompare(right.code);
-    });
-}
-function buildDoctorNextSteps(findings) {
-    const steps = new Map();
-    for (const finding of findings) {
-        switch (finding.code) {
-            case "active_missing":
-                steps.set(finding.code, "activate a healthy pack before serving or promotion checks");
-                break;
-            case "active_unhealthy":
-            case "learned_route_missing":
-                steps.set(finding.code, "repair the active pack or promote a healthy learned-routing candidate");
-                break;
-            case "candidate_missing":
-            case "promotion_blocked":
-            case "candidate_unhealthy":
-                steps.set(finding.code, "stage or repair a fresher candidate pack before attempting promotion");
-                break;
-            case "rollback_blocked":
-                steps.set(finding.code, "capture a promotion before expecting rollback readiness; previous pointer is the key guardrail");
-                break;
-            case "last_promotion_unknown":
-                steps.set(finding.code, "treat `active.updatedAt` as the last pointer move only; do not claim exact last-promotion time without previous-pointer lineage");
-                break;
-            case "supervision_unavailable":
-            case "supervision_not_flowing":
-                steps.set(finding.code, "pass `--event-export <bundle-root-or-payload>` to inspect local supervision freshness and teacher signals");
-                break;
-            case "serve_path_fail_open":
-                steps.set(finding.code, "decide whether fail-open static context is acceptable for this runtime and repair activation if it is not");
-                break;
-            case "serve_path_hard_fail":
-            case "serve_path_route_evidence_missing":
-                steps.set(finding.code, "repair the active learned-routing pack or promote a healthy candidate before serving again");
-                break;
-            case "brain_context_kernel_only":
-                steps.set(finding.code, "compare stable-kernel versus brain-compiled sources; if you expected live context, refresh exports or promote a fresher candidate pack");
-                break;
-            case "teacher_snapshot_unavailable":
-                steps.set(finding.code, "serialize `teacherLoop.snapshot()` or `await teacherLoop.flush()` and pass `--teacher-snapshot <snapshot.json>` when you need the last no-op reason");
-                break;
-            default:
-                break;
-        }
-    }
-    return [...steps.values()];
-}
-export function formatOperatorDoctorReport(report) {
-    const lines = [`DOCTOR ${report.status}`];
-    for (const finding of orderedDoctorFindings(report.findings)) {
-        lines.push(`${finding.severity.toUpperCase()} ${finding.summary}`);
-        lines.push(`  ${finding.detail}`);
-    }
-    const nextSteps = buildDoctorNextSteps(report.findings.filter((finding) => finding.severity !== "pass"));
-    if (nextSteps.length > 0) {
-        lines.push("NEXT");
-        for (const step of nextSteps) {
-            lines.push(`- ${step}`);
-        }
-    }
-    return lines.join("\n");
-}
 /**
  * Describes the kernel/brain boundary for a single compile response.
  *