@openclawbrain/openclaw 0.1.1 → 0.1.3

package/dist/src/index.js

@@ -1,20 +1,599 @@
 import { createHash } from "node:crypto";
-import { mkdirSync, readFileSync, 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 { compileRuntime } from "@openclawbrain/compiler";
-import { CONTRACT_IDS, buildNormalizedEventExport, canonicalJson, checksumJsonPayload, createFeedbackEvent, createInteractionEvent, validateNormalizedEventExport } from "@openclawbrain/contracts";
-import { inspectActivationState } from "@openclawbrain/pack-format";
+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 { 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;
+const RECORDED_SESSION_TRACE_CONTRACT = "recorded_session_trace.v1";
+const RECORDED_SESSION_FIXTURE_CONTRACT = "recorded_session_replay_fixture.v1";
+const RECORDED_SESSION_BUNDLE_CONTRACT = "recorded_session_replay_bundle.v1";
 const RUNTIME_EVENT_EXPORT_BUNDLE_CONTRACT = "normalized_event_export_bundle.v1";
+const DEFAULT_ATTACH_STATUS_MESSAGE = "openclaw attach status probe";
+const DEFAULT_ATTACH_STATUS_RUNTIME_HINTS = ["attach", "status", "probe"];
 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,
+        activationSlot: "active",
+        entrypoint: "compileRuntimeContext",
+        servedFromCandidateBeforePromotion: false,
+        learnedRouteEvidenceRequiredWhenManifestRequiresIt: true
+    },
+    eventExportBoundary: {
+        emittedContracts: [CONTRACT_IDS.interactionEvents, CONTRACT_IDS.feedbackEvents],
+        entrypoint: "runRuntimeTurn",
+        bundleWriteOptional: true,
+        writeFailuresEraseSuccessfulCompile: false,
+        learningHandoffStaysOffHotPath: true
+    },
+    activePackBoundary: {
+        servingSlot: "active",
+        inspectableSlots: ["active", "candidate", "previous"],
+        candidateServedBeforePromotion: false,
+        previousSlotUsedForRollback: true
+    },
+    promotionBoundary: {
+        candidateSlot: "candidate",
+        activeSlot: "active",
+        previousSlot: "previous",
+        requiresActivationReadyCandidate: true,
+        compileSeesCandidateOnlyAfterPromotion: true,
+        promotionHappensOffHotPath: true
+    },
+    failOpenSemantics: {
+        missingActivePackFallsBackToStaticContext: true,
+        learnedRequiredRouteArtifactDriftHardFails: true,
+        hardFailuresDisableStaticFallback: true,
+        eventExportWriteFailurePreservesCompile: true
+    },
+    runtimeResponsibilities: [
+        "runtime orchestration and session flow",
+        "prompt assembly and response delivery",
+        "guarded serve-path fail-open decisions"
+    ],
+    brainResponsibilities: [
+        "normalized event emission and export handoff",
+        "candidate pack materialization and learned route refresh",
+        "activation staging promotion and rollback",
+        "promoted-pack compilation diagnostics"
+    ]
+};
 function toErrorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
+function buildAsyncTeacherLoopNotes(input) {
+    return [
+        `teacher_queue_depth=${input.queueDepth}`,
+        `teacher_freshness=${input.latestFreshness}`,
+        `teacher_artifacts_total=${input.artifactCount}`,
+        `teacher_artifacts_emitted=${input.emittedArtifactCount}`,
+        `teacher_artifacts_deduped=${input.dedupedArtifactCount}`,
+        `teacher_budget=${input.sparseFeedback.teacherBudget}`,
+        `teacher_delay_ms=${input.sparseFeedback.teacherDelayMs}`,
+        `teacher_feedback_mask=correction:${input.sparseFeedback.feedbackMask.correction},teaching:${input.sparseFeedback.feedbackMask.teaching},approval:${input.sparseFeedback.feedbackMask.approval},suppression:${input.sparseFeedback.feedbackMask.suppression}`,
+        `teacher_feedback_eligible=${input.sparseFeedback.eligibleFeedbackCount}`,
+        `teacher_feedback_masked=${input.sparseFeedback.maskedFeedbackCount}`,
+        `teacher_feedback_delayed=${input.sparseFeedback.delayedFeedbackCount}`,
+        `teacher_feedback_budgeted_out=${input.sparseFeedback.budgetedOutFeedbackCount}`,
+        `teacher_background_amplified=${input.sparseFeedback.amplifiedBackgroundLabelCount}`,
+        `teacher_noop=${input.noOpReason}`,
+        input.materialization === null ? "teacher_materialization=noop" : `teacher_materialized_pack=${input.materialization.candidate.summary.packId}`
+    ];
+}
+function cloneAlwaysOnLearningMaterializationJobOrNull(value) {
+    return value === null ? null : structuredClone(value);
+}
+function cloneTeacherSupervisionArtifacts(value) {
+    return [...structuredClone(value)];
+}
+function cloneCanonicalSupervision(value) {
+    return structuredClone(value);
+}
+function cloneContinuousProductLoopPackVersion(value) {
+    return structuredClone(value);
+}
+function cloneContinuousProductLoopState(value) {
+    return structuredClone(value);
+}
+function buildNormalizedEventDedupId(event) {
+    return checksumJsonPayload({
+        contract: event.contract,
+        eventId: event.eventId,
+        agentId: event.agentId,
+        sessionId: event.sessionId,
+        channel: event.channel,
+        sequence: event.sequence,
+        kind: event.kind,
+        createdAt: event.createdAt,
+        source: event.source,
+        packId: "packId" in event ? event.packId ?? null : null,
+        content: "content" in event ? event.content : null,
+        messageId: event.messageId ?? null,
+        relatedInteractionId: "relatedInteractionId" in event ? event.relatedInteractionId ?? null : null
+    });
+}
+function mergeRuntimeEventHistory(current, incoming) {
+    const merged = sortNormalizedEvents([
+        ...current.interactionEvents,
+        ...current.feedbackEvents,
+        ...incoming.interactionEvents,
+        ...incoming.feedbackEvents
+    ]);
+    const deduped = [];
+    const seen = new Set();
+    for (const event of merged) {
+        const dedupId = buildNormalizedEventDedupId(event);
+        if (seen.has(dedupId)) {
+            continue;
+        }
+        seen.add(dedupId);
+        deduped.push(event);
+    }
+    return {
+        interactionEvents: deduped.filter((event) => event.contract === CONTRACT_IDS.interactionEvents),
+        feedbackEvents: deduped.filter((event) => event.contract === CONTRACT_IDS.feedbackEvents)
+    };
+}
+function buildContinuousTurnExport(turn, loopRoot) {
+    const exportSeed = checksumJsonPayload({
+        sessionId: turn.sessionId,
+        channel: turn.channel,
+        sourceStream: turn.sourceStream ?? null,
+        userMessage: turn.userMessage,
+        createdAt: turn.createdAt ?? null,
+        sequenceStart: turn.sequenceStart ?? null,
+        compileCreatedAt: turn.compile?.createdAt ?? null,
+        delivery: turn.delivery === false
+            ? false
+            : turn.delivery === undefined || turn.delivery === null
+                ? null
+                : turn.delivery === true
+                    ? true
+                    : {
+                        createdAt: turn.delivery.createdAt ?? null,
+                        messageId: turn.delivery.messageId ?? null,
+                        sequence: turn.delivery.sequence ?? null
+                    },
+        feedback: (turn.feedback ?? [])
+            .filter((item) => item !== null)
+            .map((item) => ({
+            content: item.content,
+            createdAt: item.createdAt ?? null,
+            sequence: item.sequence ?? null,
+            kind: item.kind ?? null,
+            messageId: item.messageId ?? null,
+            relatedInteractionId: item.relatedInteractionId ?? null
+        }))
+    })
+        .replace(/^sha256-/u, "")
+        .slice(0, 12);
+    const exportName = `${turn.sessionId}-${exportSeed}`;
+    return {
+        rootDir: path.join(loopRoot, "event-exports", exportName),
+        exportName
+    };
+}
+function withContinuousTurnExport(turn, loopRoot) {
+    if (turn.export !== undefined && turn.export !== null) {
+        return {
+            ...turn,
+            export: {
+                ...turn.export
+            }
+        };
+    }
+    return {
+        ...turn,
+        export: buildContinuousTurnExport(turn, loopRoot)
+    };
+}
+function buildPackVersion(version, target) {
+    return {
+        version,
+        packId: target.packId,
+        routePolicy: target.routePolicy,
+        routerIdentity: target.routerIdentity,
+        workspaceSnapshot: target.workspaceSnapshot,
+        workspaceRevision: target.workspaceRevision,
+        eventRange: {
+            start: target.eventRange.start,
+            end: target.eventRange.end,
+            count: target.eventRange.count
+        },
+        eventExportDigest: target.eventExportDigest,
+        builtAt: target.builtAt
+    };
+}
+function buildLearningCandidateTarget(candidate) {
+    return {
+        packId: candidate.summary.packId,
+        routePolicy: candidate.summary.routePolicy,
+        routerIdentity: candidate.payloads.router?.routerIdentity ?? null,
+        workspaceSnapshot: candidate.summary.workspaceSnapshot,
+        workspaceRevision: candidate.manifest.provenance.workspace.revision,
+        eventRange: {
+            start: candidate.summary.eventRange.start,
+            end: candidate.summary.eventRange.end,
+            count: candidate.summary.eventRange.count
+        },
+        eventExportDigest: candidate.summary.eventExportDigest,
+        builtAt: candidate.manifest.provenance.builtAt
+    };
+}
+function registerPackVersion(state, target) {
+    const existing = state.packLineage.find((entry) => entry.packId === target.packId);
+    if (existing !== undefined) {
+        return cloneContinuousProductLoopPackVersion(existing);
+    }
+    const created = buildPackVersion(state.nextPackVersion, target);
+    state.packLineage.push(cloneContinuousProductLoopPackVersion(created));
+    state.nextPackVersion += 1;
+    return created;
+}
+function tryReadActivePackTarget(rootDir) {
+    try {
+        return describeActivationTarget(rootDir, "active", { requireActivationReady: true });
+    }
+    catch {
+        return null;
+    }
+}
+function syncContinuousActivePack(state) {
+    const activeTarget = tryReadActivePackTarget(state.activationRoot);
+    if (activeTarget === null) {
+        state.currentActivePack = null;
+        state.activePackVersion = 0;
+        return null;
+    }
+    const activePack = registerPackVersion(state, activeTarget);
+    state.currentActivePack = cloneContinuousProductLoopPackVersion(activePack);
+    state.activePackVersion = activePack.version;
+    return activePack;
+}
+function buildContinuousPackRoot(loopRoot, packVersion) {
+    return path.join(loopRoot, "packs", `v${String(packVersion.version).padStart(4, "0")}-${packVersion.packId}`);
+}
+export function buildCanonicalSupervision(normalizedEventExport) {
+    const feedback = normalizedEventExport.feedbackEvents.map((event) => ({
+        eventId: event.eventId,
+        kind: event.kind,
+        sequence: event.sequence,
+        createdAt: event.createdAt,
+        content: event.content,
+        relatedInteractionId: event.relatedInteractionId ?? null
+    }));
+    const compilePackIds = [
+        ...new Set(normalizedEventExport.interactionEvents.flatMap((event) => event.kind === "memory_compiled" && event.packId ? [event.packId] : []))
+    ];
+    const relatedInteractionIds = [...new Set(feedback.flatMap((event) => (event.relatedInteractionId ? [event.relatedInteractionId] : [])))];
+    const feedbackCounts = {
+        corrections: feedback.filter((event) => event.kind === "correction").length,
+        teachings: feedback.filter((event) => event.kind === "teaching").length,
+        approvals: feedback.filter((event) => event.kind === "approval").length,
+        suppressions: feedback.filter((event) => event.kind === "suppression").length
+    };
+    const supervisionDigest = checksumJsonPayload({
+        exportDigest: normalizedEventExport.provenance.exportDigest,
+        eventRange: {
+            start: normalizedEventExport.range.start,
+            end: normalizedEventExport.range.end,
+            count: normalizedEventExport.range.count
+        },
+        sourceStreams: normalizedEventExport.provenance.sourceStreams,
+        humanLabelCount: normalizedEventExport.provenance.learningSurface.labelHarvest.humanLabels,
+        selfLabelCount: normalizedEventExport.provenance.learningSurface.labelHarvest.selfLabels,
+        feedback,
+        compilePackIds,
+        relatedInteractionIds
+    });
+    return {
+        runtimeOwner: "openclaw",
+        exportDigest: normalizedEventExport.provenance.exportDigest,
+        supervisionDigest,
+        sessionId: normalizedEventExport.provenance.sessionId,
+        channel: normalizedEventExport.provenance.channel,
+        eventRange: {
+            start: normalizedEventExport.range.start,
+            end: normalizedEventExport.range.end,
+            count: normalizedEventExport.range.count
+        },
+        sourceStreams: [...normalizedEventExport.provenance.sourceStreams],
+        humanLabelCount: normalizedEventExport.provenance.learningSurface.labelHarvest.humanLabels,
+        selfLabelCount: normalizedEventExport.provenance.learningSurface.labelHarvest.selfLabels,
+        feedbackCounts,
+        compilePackIds,
+        relatedInteractionIds,
+        feedback
+    };
+}
+export function createContinuousProductLoopState(input) {
+    const activationRoot = path.resolve(normalizeNonEmptyString(input.activationRoot, "activationRoot"));
+    const loopRoot = path.resolve(normalizeNonEmptyString(input.loopRoot, "loopRoot"));
+    const activeTarget = tryReadActivePackTarget(activationRoot);
+    const activePack = activeTarget === null ? null : buildPackVersion(1, activeTarget);
+    return {
+        runtimeOwner: "openclaw",
+        activationRoot,
+        loopRoot,
+        interactionEvents: [],
+        feedbackEvents: [],
+        learner: createAlwaysOnLearningRuntimeState(),
+        runtimePlasticity: null,
+        activePackVersion: activePack?.version ?? 0,
+        currentActivePack: activePack === null ? null : cloneContinuousProductLoopPackVersion(activePack),
+        candidatePack: null,
+        packLineage: activePack === null ? [] : [cloneContinuousProductLoopPackVersion(activePack)],
+        nextPackVersion: activePack === null ? 1 : 2,
+        promotionCount: 0,
+        lastSupervision: null
+    };
+}
+function mergeUniqueEvents(current, additions) {
+    const merged = new Map();
+    for (const event of [...current, ...additions]) {
+        merged.set(buildNormalizedEventDedupId(event), structuredClone(event));
+    }
+    return [...merged.values()].sort((left, right) => left.sequence - right.sequence || left.createdAt.localeCompare(right.createdAt));
+}
+function mergeTeacherArtifacts(current, additions) {
+    const merged = new Map();
+    for (const artifact of [...current, ...additions]) {
+        const existing = merged.get(artifact.dedupId);
+        if (existing === undefined ||
+            Date.parse(artifact.freshness.observedAt) > Date.parse(existing.freshness.observedAt) ||
+            (artifact.freshness.observedAt === existing.freshness.observedAt && artifact.artifactId.localeCompare(existing.artifactId) < 0)) {
+            merged.set(artifact.dedupId, structuredClone(artifact));
+        }
+    }
+    return [...merged.values()].sort((left, right) => {
+        if (left.freshness.status !== right.freshness.status) {
+            return left.freshness.status === "fresh" ? -1 : 1;
+        }
+        if (left.createdAt !== right.createdAt) {
+            return Date.parse(right.createdAt) - Date.parse(left.createdAt);
+        }
+        return left.artifactId.localeCompare(right.artifactId);
+    });
+}
+function latestTeacherFreshness(artifacts) {
+    return artifacts[0]?.freshness.status ?? "none";
+}
+export class AsyncTeacherLiveLoop {
+    input;
+    queueCapacity;
+    staleAfterMs;
+    queuedExportDigests = new Set();
+    seenExportDigests = new Set();
+    queue = [];
+    drainPromise = null;
+    interactionEvents = [];
+    feedbackEvents = [];
+    teacherArtifacts = [];
+    learnerState = createAlwaysOnLearningRuntimeState();
+    lastMaterialization = null;
+    diagnostics = {
+        acceptedExportCount: 0,
+        processedExportCount: 0,
+        duplicateExportCount: 0,
+        droppedExportCount: 0,
+        emittedArtifactCount: 0,
+        dedupedArtifactCount: 0,
+        lastProcessedAt: null,
+        latestFreshness: "none",
+        lastNoOpReason: "none",
+        notes: buildAsyncTeacherLoopNotes({
+            queueDepth: 0,
+            latestFreshness: "none",
+            artifactCount: 0,
+            emittedArtifactCount: 0,
+            dedupedArtifactCount: 0,
+            sparseFeedback: this.learnerState.sparseFeedback,
+            noOpReason: "none",
+            materialization: null
+        })
+    };
+    constructor(input) {
+        this.input = input;
+        this.queueCapacity = input.maxQueuedExports ?? DEFAULT_ASYNC_TEACHER_QUEUE_CAPACITY;
+        this.staleAfterMs = input.staleAfterMs ?? DEFAULT_TEACHER_SUPERVISION_STALE_AFTER_MS;
+        if (!Number.isInteger(this.queueCapacity) || this.queueCapacity <= 0) {
+            throw new Error("maxQueuedExports must be a positive integer");
+        }
+        if (!Number.isInteger(this.staleAfterMs) || this.staleAfterMs <= 0) {
+            throw new Error("staleAfterMs must be a positive integer");
+        }
+    }
+    enqueueNormalizedEventExport(normalizedEventExport, options = {}) {
+        const validationErrors = validateNormalizedEventExport(normalizedEventExport);
+        if (validationErrors.length > 0) {
+            throw new Error(`normalized event export is invalid: ${validationErrors.join("; ")}`);
+        }
+        const exportDigest = normalizedEventExport.provenance.exportDigest;
+        if (this.seenExportDigests.has(exportDigest) || this.queuedExportDigests.has(exportDigest)) {
+            this.diagnostics.duplicateExportCount += 1;
+            this.diagnostics.lastNoOpReason = "duplicate_export";
+            this.refreshNotes();
+            return {
+                accepted: false,
+                exportDigest,
+                queueDepth: this.queue.length,
+                notes: [...this.diagnostics.notes],
+                reason: "duplicate_export"
+            };
+        }
+        if (this.queue.length >= this.queueCapacity) {
+            this.diagnostics.droppedExportCount += 1;
+            this.diagnostics.lastNoOpReason = "queue_full";
+            this.refreshNotes();
+            return {
+                accepted: false,
+                exportDigest,
+                queueDepth: this.queue.length,
+                notes: [...this.diagnostics.notes],
+                reason: "queue_full"
+            };
+        }
+        const observedAt = options.observedAt ?? normalizedEventExport.range.lastCreatedAt ?? normalizedEventExport.range.firstCreatedAt ?? new Date().toISOString();
+        this.queue.push({
+            jobId: `teacher-loop-${createHash("sha256").update(`${exportDigest}:${observedAt}`).digest("hex")}`,
+            exportDigest,
+            observedAt,
+            normalizedEventExport: structuredClone(normalizedEventExport)
+        });
+        this.queuedExportDigests.add(exportDigest);
+        this.diagnostics.acceptedExportCount += 1;
+        this.refreshNotes();
+        void this.ensureDrain();
+        return {
+            accepted: true,
+            exportDigest,
+            queueDepth: this.queue.length,
+            notes: [...this.diagnostics.notes],
+            reason: null
+        };
+    }
+    async flush() {
+        await this.ensureDrain();
+        return this.snapshot();
+    }
+    snapshot() {
+        return {
+            runtimeOwner: "openclaw",
+            queue: {
+                capacity: this.queueCapacity,
+                depth: this.queue.length,
+                running: this.drainPromise !== null
+            },
+            teacher: {
+                artifactCount: this.teacherArtifacts.length,
+                artifacts: cloneTeacherSupervisionArtifacts(this.teacherArtifacts),
+                latestFreshness: this.diagnostics.latestFreshness
+            },
+            learner: {
+                state: structuredClone(this.learnerState),
+                lastMaterialization: cloneAlwaysOnLearningMaterializationJobOrNull(this.lastMaterialization)
+            },
+            diagnostics: {
+                ...this.diagnostics,
+                notes: [...this.diagnostics.notes]
+            }
+        };
+    }
+    async ensureDrain() {
+        if (this.drainPromise === null) {
+            this.drainPromise = this.drain().finally(() => {
+                this.drainPromise = null;
+            });
+        }
+        await this.drainPromise;
+        if (this.queue.length > 0) {
+            await this.ensureDrain();
+        }
+    }
+    async drain() {
+        while (this.queue.length > 0) {
+            const job = this.queue.shift();
+            this.queuedExportDigests.delete(job.exportDigest);
+            this.seenExportDigests.add(job.exportDigest);
+            this.interactionEvents = mergeUniqueEvents(this.interactionEvents, job.normalizedEventExport.interactionEvents);
+            this.feedbackEvents = mergeUniqueEvents(this.feedbackEvents, job.normalizedEventExport.feedbackEvents);
+            const mergedNormalizedEventExport = buildNormalizedEventExport({
+                interactionEvents: this.interactionEvents,
+                feedbackEvents: this.feedbackEvents
+            });
+            const builtArtifacts = buildTeacherSupervisionArtifactsFromNormalizedEventExport({
+                normalizedEventExport: mergedNormalizedEventExport,
+                observedAt: job.observedAt,
+                staleAfterMs: this.staleAfterMs,
+                ...(this.input.sparseFeedback !== undefined ? { sparseFeedback: this.input.sparseFeedback } : {})
+            });
+            const currentDedupIds = new Set(this.teacherArtifacts.map((artifact) => artifact.dedupId));
+            const nextTeacherArtifacts = mergeTeacherArtifacts(this.teacherArtifacts, builtArtifacts);
+            const emittedArtifactCount = builtArtifacts.filter((artifact) => !currentDedupIds.has(artifact.dedupId)).length;
+            const dedupedArtifactCount = builtArtifacts.length - emittedArtifactCount;
+            this.teacherArtifacts = nextTeacherArtifacts;
+            const learnerResult = advanceAlwaysOnLearningRuntime({
+                packLabel: this.input.packLabel,
+                workspace: this.input.workspace,
+                interactionEvents: this.interactionEvents,
+                feedbackEvents: this.feedbackEvents,
+                teacherSupervisionArtifacts: this.teacherArtifacts,
+                learnedRouting: this.input.learnedRouting,
+                state: this.learnerState,
+                builtAt: this.input.builtAt ?? job.observedAt,
+                ...(this.input.offlineArtifacts !== undefined ? { offlineArtifacts: this.input.offlineArtifacts } : {}),
+                ...(this.input.structuralOps !== undefined ? { structuralOps: this.input.structuralOps } : {}),
+                ...(this.input.sparseFeedback !== undefined ? { sparseFeedback: this.input.sparseFeedback } : {}),
+                ...(this.input.liveSliceSize !== undefined ? { liveSliceSize: this.input.liveSliceSize } : {}),
+                ...(this.input.backfillSliceSize !== undefined ? { backfillSliceSize: this.input.backfillSliceSize } : {}),
+                ...(this.input.cadence !== undefined ? { cadence: this.input.cadence } : {})
+            });
+            this.learnerState = structuredClone(learnerResult.state);
+            this.lastMaterialization = cloneAlwaysOnLearningMaterializationJobOrNull(learnerResult.materialization);
+            this.diagnostics.processedExportCount += 1;
+            this.diagnostics.emittedArtifactCount += emittedArtifactCount;
+            this.diagnostics.dedupedArtifactCount += dedupedArtifactCount;
+            this.diagnostics.lastProcessedAt = job.observedAt;
+            this.diagnostics.latestFreshness = latestTeacherFreshness(this.teacherArtifacts);
+            this.diagnostics.lastNoOpReason = emittedArtifactCount === 0 ? "no_teacher_artifacts" : "none";
+            this.refreshNotes();
+        }
+    }
+    refreshNotes() {
+        this.diagnostics.notes = buildAsyncTeacherLoopNotes({
+            queueDepth: this.queue.length,
+            latestFreshness: this.diagnostics.latestFreshness,
+            artifactCount: this.teacherArtifacts.length,
+            emittedArtifactCount: this.diagnostics.emittedArtifactCount,
+            dedupedArtifactCount: this.diagnostics.dedupedArtifactCount,
+            sparseFeedback: this.learnerState.sparseFeedback,
+            noOpReason: this.diagnostics.lastNoOpReason,
+            materialization: this.lastMaterialization
+        });
+    }
+}
+export function createAsyncTeacherLiveLoop(input) {
+    return new AsyncTeacherLiveLoop(input);
+}
 function readJsonFile(filePath) {
     return JSON.parse(readFileSync(filePath, "utf8"));
 }
@@ -209,15 +788,38 @@ export function formatPromptContext(compileResponse) {
     lines.push("[/BRAIN_CONTEXT]");
     return `${lines.join("\n")}\n`;
 }
-function fallbackCompileResult(error, activationRoot) {
+function failOpenCompileResult(error, activationRoot) {
     return {
         ok: false,
         fallbackToStaticContext: true,
+        hardRequirementViolated: false,
         activationRoot: path.resolve(activationRoot),
         error: toErrorMessage(error),
         brainContext: ""
     };
 }
+function classifyCompileFailure(error, activationRoot) {
+    const resolvedActivationRoot = path.resolve(activationRoot);
+    try {
+        const inspection = inspectActivationState(resolvedActivationRoot);
+        const active = inspection.active;
+        if (active !== null && active.routePolicy === "requires_learned_routing") {
+            const failureReason = active.findings.length > 0 ? active.findings.join("; ") : toErrorMessage(error);
+            return {
+                ok: false,
+                fallbackToStaticContext: false,
+                hardRequirementViolated: true,
+                activationRoot: resolvedActivationRoot,
+                error: `Learned-routing hotpath hard requirement violated for active pack ${active.packId} (routerIdentity=${active.routerIdentity ?? "null"}): ${failureReason}`,
+                brainContext: ""
+            };
+        }
+    }
+    catch {
+        return failOpenCompileResult(error, resolvedActivationRoot);
+    }
+    return failOpenCompileResult(error, resolvedActivationRoot);
+}
 export function resolveActivePackForCompile(activationRoot) {
     const resolvedActivationRoot = path.resolve(normalizeNonEmptyString(activationRoot, "activationRoot"));
     const inspection = inspectActivationState(resolvedActivationRoot);
@@ -240,28 +842,435 @@ export function compileRuntimeContext(input) {
     const runtimeHints = normalizeRuntimeHints(input.runtimeHints);
     try {
         const target = resolveActivePackForCompile(activationRoot);
-        const compileResponse = compileRuntime(target.activePointer.packRootDir, {
+        const compile = compileRuntimeFromActivation(activationRoot, {
             contract: CONTRACT_IDS.runtimeCompile,
             agentId,
             userMessage: normalizeNonEmptyString(input.message, "message"),
             maxContextBlocks: normalizeNonNegativeInteger(input.maxContextBlocks, "maxContextBlocks", 4),
+            ...(input.maxContextChars !== undefined
+                ? { maxContextChars: normalizeNonNegativeInteger(input.maxContextChars, "maxContextChars", input.maxContextChars) }
+                : {}),
             modeRequested: normalizeMode(input.mode),
             activePackId: target.activePointer.packId,
+            ...(input.compactionMode !== undefined ? { compactionMode: input.compactionMode } : {}),
             ...(runtimeHints.length > 0 ? { runtimeHints } : {})
         });
+        const compileResponse = {
+            ...compile.response,
+            diagnostics: {
+                ...compile.response.diagnostics,
+                notes: [...compile.response.diagnostics.notes, "OpenClaw remains the runtime owner"]
+            }
+        };
         return {
             ok: true,
             fallbackToStaticContext: false,
+            hardRequirementViolated: false,
             activationRoot,
-            activePackId: target.activePointer.packId,
+            activePackId: compile.target.packId,
             packRootDir: path.resolve(target.activePointer.packRootDir),
             compileResponse,
             brainContext: formatPromptContext(compileResponse)
         };
     }
     catch (error) {
-        return fallbackCompileResult(error, activationRoot);
+        return classifyCompileFailure(error, activationRoot);
+    }
+}
+function readDiagnosticNoteValue(notes, prefix) {
+    const note = notes.find((entry) => entry.startsWith(prefix));
+    return note === undefined ? null : note.slice(prefix.length);
+}
+function readDiagnosticNoteList(notes, prefix) {
+    const value = readDiagnosticNoteValue(notes, prefix);
+    if (value === null || value.length === 0) {
+        return [];
+    }
+    return value
+        .split("|")
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0);
+}
+function sortedUniqueStrings(values) {
+    return [...new Set(values.filter((value) => value.length > 0))].sort((left, right) => left.localeCompare(right));
+}
+function isStableKernelContextBlock(block) {
+    if (block.id.includes(":event:") || block.id.includes(":teacher:")) {
+        return false;
+    }
+    if (block.source.startsWith("split:") || block.source.startsWith("merge:")) {
+        return false;
+    }
+    return true;
+}
+function buildContextAttributionSummary(input) {
+    const selectionTiers = readDiagnosticNoteValue(input.notes ?? [], "selection_tiers=");
+    const selectedContext = [...(input.selectedContext ?? [])];
+    const stableKernelBlocks = selectedContext.filter((block) => isStableKernelContextBlock(block));
+    const brainCompiledBlocks = selectedContext.filter((block) => !isStableKernelContextBlock(block));
+    if (input.unprobed) {
+        return {
+            selectedContextCount: 0,
+            stableKernelBlockCount: 0,
+            brainCompiledBlockCount: 0,
+            stableKernelSources: [],
+            brainCompiledSources: [],
+            selectionTiers,
+            evidence: "unprobed",
+            detail: "compile probe was not run, so kernel-vs-brain attribution is unknown"
+        };
+    }
+    if (input.hardRequirementViolated) {
+        return {
+            selectedContextCount: 0,
+            stableKernelBlockCount: 0,
+            brainCompiledBlockCount: 0,
+            stableKernelSources: [],
+            brainCompiledSources: [],
+            selectionTiers,
+            evidence: "hard_fail",
+            detail: "learned-routing hard requirement failed before any compiled brain context could be selected"
+        };
+    }
+    if (input.fallbackToStaticContext) {
+        return {
+            selectedContextCount: 0,
+            stableKernelBlockCount: 0,
+            brainCompiledBlockCount: 0,
+            stableKernelSources: [],
+            brainCompiledSources: [],
+            selectionTiers,
+            evidence: "fail_open_static_context",
+            detail: "serve probe fell back to static context, so no compiled brain context was selected"
+        };
+    }
+    const evidence = brainCompiledBlocks.length > 0
+        ? input.usedLearnedRouteFn === true
+            ? "route_fn_and_brain_context"
+            : "brain_context_only"
+        : input.usedLearnedRouteFn === true
+            ? "route_fn_only"
+            : "stable_kernel_only";
+    const detailPrefix = `selected=${selectedContext.length}; tiers=${selectionTiers ?? "unknown"}; kernel=${stableKernelBlocks.length}; brain=${brainCompiledBlocks.length}`;
+    const detail = evidence === "route_fn_and_brain_context"
+        ? `${detailPrefix}; learned route ran and non-seed brain-compiled context was selected`
+        : evidence === "brain_context_only"
+            ? `${detailPrefix}; non-seed brain-compiled context was selected without learned-route evidence`
+            : evidence === "route_fn_only"
+                ? `${detailPrefix}; learned route ran but selected context stayed inside the stable kernel`
+                : `${detailPrefix}; selected context stayed inside the stable kernel`;
+    return {
+        selectedContextCount: selectedContext.length,
+        stableKernelBlockCount: stableKernelBlocks.length,
+        brainCompiledBlockCount: brainCompiledBlocks.length,
+        stableKernelSources: sortedUniqueStrings(stableKernelBlocks.map((block) => block.source)),
+        brainCompiledSources: sortedUniqueStrings(brainCompiledBlocks.map((block) => block.source)),
+        selectionTiers,
+        evidence,
+        detail
+    };
+}
+function buildAttachCompileStatus(result, observability, activePackId) {
+    if (!result.ok) {
+        return {
+            ok: false,
+            fallbackToStaticContext: result.fallbackToStaticContext,
+            hardRequirementViolated: result.hardRequirementViolated,
+            activePackId,
+            usedLearnedRouteFn: null,
+            routerIdentity: observability?.learnedRouteFn.routerIdentity ?? null,
+            initMode: observability?.initHandoff.initMode ?? null,
+            handoffState: observability?.initHandoff.handoffState ?? null,
+            seedSources: observability?.initHandoff.seedSources ?? [],
+            contextAttribution: buildContextAttributionSummary({
+                fallbackToStaticContext: result.fallbackToStaticContext,
+                hardRequirementViolated: result.hardRequirementViolated,
+                usedLearnedRouteFn: null
+            }),
+            notes: [],
+            error: result.error
+        };
+    }
+    const notes = [...result.compileResponse.diagnostics.notes];
+    const contextAttribution = buildContextAttributionSummary({
+        fallbackToStaticContext: false,
+        hardRequirementViolated: false,
+        usedLearnedRouteFn: result.compileResponse.diagnostics.usedLearnedRouteFn,
+        selectedContext: result.compileResponse.selectedContext,
+        notes
+    });
+    return {
+        ok: true,
+        fallbackToStaticContext: false,
+        hardRequirementViolated: false,
+        activePackId: result.activePackId,
+        usedLearnedRouteFn: result.compileResponse.diagnostics.usedLearnedRouteFn,
+        routerIdentity: result.compileResponse.diagnostics.routerIdentity,
+        initMode: readDiagnosticNoteValue(notes, "init_mode=") ?? observability?.initHandoff.initMode ?? null,
+        handoffState: readDiagnosticNoteValue(notes, "handoff_state=") ?? observability?.initHandoff.handoffState ?? null,
+        seedSources: readDiagnosticNoteList(notes, "seed_sources=").length > 0
+            ? readDiagnosticNoteList(notes, "seed_sources=")
+            : observability?.initHandoff.seedSources ?? [],
+        contextAttribution,
+        notes,
+        error: null
+    };
+}
+function buildAttachSuccessSignals(input) {
+    const signals = [];
+    const activeTarget = input.observability?.target ?? null;
+    if (input.inspection.active?.activationReady) {
+        signals.push(`active_pack_ready:${input.inspection.active.packId}`);
+    }
+    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"}`);
+    }
+    if (input.compile !== null) {
+        signals.push(`context:${input.compile.contextAttribution.evidence}`);
+        signals.push(`context_blocks:kernel=${input.compile.contextAttribution.stableKernelBlockCount},brain=${input.compile.contextAttribution.brainCompiledBlockCount}`);
+    }
+    if (input.compile?.handoffState !== null && input.compile?.handoffState !== undefined) {
+        signals.push(`handoff:${input.compile.handoffState}`);
+    }
+    if (input.inspection.active?.routePolicy === "requires_learned_routing") {
+        if (input.compile?.ok && input.compile.usedLearnedRouteFn === true && input.compile.routerIdentity !== null) {
+            signals.push(`learned_route_compile_verified:${input.compile.routerIdentity}`);
+        }
+    }
+    else if (input.compile?.ok) {
+        signals.push("heuristic_compile_verified");
+    }
+    return signals;
+}
+function buildAttachStatusCompileInput(activationRoot, compile) {
+    if (compile === false) {
+        return null;
+    }
+    return {
+        activationRoot,
+        agentId: normalizeOptionalString(compile?.agentId) ?? `${DEFAULT_AGENT_ID}-attach-status`,
+        message: normalizeOptionalString(compile?.message) ?? DEFAULT_ATTACH_STATUS_MESSAGE,
+        ...(compile?.maxContextBlocks !== undefined ? { maxContextBlocks: compile.maxContextBlocks } : {}),
+        ...(compile?.maxContextChars !== undefined ? { maxContextChars: compile.maxContextChars } : {}),
+        ...(compile?.mode !== undefined ? { mode: compile.mode } : {}),
+        ...(compile?.compactionMode !== undefined ? { compactionMode: compile.compactionMode } : {}),
+        runtimeHints: compile?.runtimeHints ?? [...DEFAULT_ATTACH_STATUS_RUNTIME_HINTS]
+    };
+}
+export function describeAttachStatus(input) {
+    const activationRoot = path.resolve(normalizeNonEmptyString(input.activationRoot, "activationRoot"));
+    const inspection = inspectActivationState(activationRoot);
+    const activeObservability = inspection.active === null ? null : describeActivationObservability(activationRoot, "active");
+    const compileInput = buildAttachStatusCompileInput(activationRoot, input.compile);
+    const compile = compileInput === null
+        ? null
+        : buildAttachCompileStatus(compileRuntimeContext(compileInput), activeObservability, inspection.active?.packId ?? null);
+    return {
+        runtimeOwner: "openclaw",
+        activationRoot,
+        inspection,
+        activeObservability,
+        compile,
+        landingBoundaries: structuredClone(OPENCLAW_LANDING_BOUNDARIES_V1),
+        successSignals: buildAttachSuccessSignals({
+            inspection,
+            observability: activeObservability,
+            compile
+        })
+    };
+}
+export function rollbackRuntimeAttach(input) {
+    const activationRoot = path.resolve(normalizeNonEmptyString(input.activationRoot, "activationRoot"));
+    const updatedAt = normalizeIsoTimestamp(input.updatedAt, "updatedAt", new Date().toISOString());
+    const dryRun = input.dryRun === true;
+    const before = inspectActivationState(activationRoot, updatedAt);
+    const findings = [...before.rollback.findings];
+    const allowed = before.rollback.allowed;
+    if (!allowed) {
+        return {
+            runtimeOwner: "openclaw",
+            activationRoot,
+            updatedAt,
+            dryRun,
+            allowed,
+            findings,
+            before: {
+                activePackId: before.active?.packId ?? before.pointers.active?.packId ?? null,
+                candidatePackId: before.candidate?.packId ?? before.pointers.candidate?.packId ?? null,
+                previousPackId: before.previous?.packId ?? before.pointers.previous?.packId ?? null
+            },
+            after: null,
+            restoredPackId: null,
+            parkedCandidatePackId: null
+        };
+    }
+    const after = dryRun
+        ? before.rollback.nextPointers
+        : rollbackActivePack(activationRoot, {
+            updatedAt,
+            reason: "runtime_attach_rollback"
+        }).pointers;
+    return {
+        runtimeOwner: "openclaw",
+        activationRoot,
+        updatedAt,
+        dryRun,
+        allowed,
+        findings,
+        before: {
+            activePackId: before.active?.packId ?? before.pointers.active?.packId ?? null,
+            candidatePackId: before.candidate?.packId ?? before.pointers.candidate?.packId ?? null,
+            previousPackId: before.previous?.packId ?? before.pointers.previous?.packId ?? null
+        },
+        after: after === null ? null : {
+            activePackId: after.active?.packId ?? null,
+            candidatePackId: after.candidate?.packId ?? null,
+            previousPackId: after.previous?.packId ?? null
+        },
+        restoredPackId: after?.active?.packId ?? null,
+        parkedCandidatePackId: after?.candidate?.packId ?? null
+    };
+}
+function resolveBootstrapNormalizedEventExport(input) {
+    const interactionEvents = [...(input.interactionEvents ?? [])];
+    const feedbackEvents = [...(input.feedbackEvents ?? [])];
+    if (input.normalizedEventExport !== undefined && (interactionEvents.length > 0 || feedbackEvents.length > 0)) {
+        throw new Error("Provide normalizedEventExport or interactionEvents/feedbackEvents, not both");
+    }
+    const normalizedEventExport = input.normalizedEventExport !== undefined
+        ? canonicalizeBootstrapNormalizedEventExport(input.normalizedEventExport)
+        : buildNormalizedEventExport({
+            interactionEvents,
+            feedbackEvents
+        });
+    const validationErrors = validateNormalizedEventExport(normalizedEventExport);
+    if (validationErrors.length > 0) {
+        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"));
+    const normalizedEventExport = resolveBootstrapNormalizedEventExport(input);
+    const builtAt = normalizeIsoTimestamp(input.builtAt, "builtAt", normalizedEventExport.range.lastCreatedAt ?? normalizedEventExport.range.firstCreatedAt ?? new Date().toISOString());
+    const activatedAt = normalizeIsoTimestamp(input.activatedAt, "activatedAt", builtAt);
+    const teacherSupervisionArtifacts = buildTeacherSupervisionArtifactsFromNormalizedEventExport({
+        normalizedEventExport,
+        observedAt: activatedAt,
+        ...(input.sparseFeedback !== undefined ? { sparseFeedback: input.sparseFeedback } : {})
+    });
+    const descriptor = materializeCandidatePackFromNormalizedEventExport(packRoot, {
+        packLabel: normalizeNonEmptyString(input.packLabel, "packLabel"),
+        workspace: input.workspace,
+        normalizedEventExport,
+        teacherSupervisionArtifacts,
+        learnedRouting: input.learnedRouting ?? true,
+        builtAt,
+        ...(input.offlineArtifacts !== undefined ? { offlineArtifacts: input.offlineArtifacts } : {}),
+        ...(input.structuralOps !== undefined ? { structuralOps: input.structuralOps } : {}),
+        ...(input.sparseFeedback !== undefined ? { sparseFeedback: input.sparseFeedback } : {})
+    });
+    activatePack(activationRoot, packRoot, {
+        updatedAt: activatedAt,
+        reason: "attach_bootstrap"
+    });
+    return {
+        runtimeOwner: "openclaw",
+        activationRoot,
+        packRoot,
+        packId: descriptor.manifest.packId,
+        normalizedEventExport,
+        status: describeAttachStatus({
+            activationRoot,
+            ...(input.compile !== undefined ? { compile: input.compile } : {})
+        })
+    };
+}
+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) {
@@ -277,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,
@@ -289,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) {
@@ -310,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,
@@ -322,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`);
@@ -364,6 +1387,7 @@ function buildFeedbackEvents(input) {
                 stream: input.sourceStream
             },
             content,
+            attribution,
             ...(messageId !== undefined ? { messageId } : {}),
             ...(relatedInteractionId !== undefined ? { relatedInteractionId } : {})
         });
@@ -396,6 +1420,7 @@ export function buildNormalizedRuntimeEventExport(turn, compileResult) {
         nextSequence,
         defaultCreatedAt: compileCreatedAt,
         compileInteraction,
+        compileResult,
         agentId
     });
     const deliveryInteraction = buildDeliveryInteractionEvent({
@@ -467,8 +1492,35 @@ export function runRuntimeTurn(turn, options = {}) {
     };
     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);
+    }
     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,
@@ -492,4 +1544,1565 @@ export function runRuntimeTurn(turn, options = {}) {
         };
     }
 }
+export function runContinuousProductLoopTurn(input) {
+    const activationRoot = path.resolve(normalizeNonEmptyString(input.activationRoot, "activationRoot"));
+    const loopRoot = path.resolve(normalizeNonEmptyString(input.loopRoot, "loopRoot"));
+    const failOpen = input.failOpen !== false;
+    const currentState = cloneContinuousProductLoopState(input.state ??
+        createContinuousProductLoopState({
+            activationRoot,
+            loopRoot
+        }));
+    currentState.activationRoot = activationRoot;
+    currentState.loopRoot = loopRoot;
+    const activeBeforeTurn = syncContinuousActivePack(currentState);
+    const compileActiveVersion = activeBeforeTurn?.version ?? 0;
+    const compileActivePackId = activeBeforeTurn?.packId ?? null;
+    const turn = withContinuousTurnExport(input.turn, loopRoot);
+    const turnResult = runRuntimeTurn(turn, {
+        activationRoot,
+        failOpen
+    });
+    const learningWarnings = [];
+    let supervision = null;
+    const learning = {
+        warnings: learningWarnings,
+        supervisionDigest: null,
+        bridgeDigest: null,
+        selectedSliceIds: [],
+        materializationJobId: null,
+        materializationReason: null,
+        materializationLane: null,
+        candidateRootDir: null,
+        candidatePack: currentState.candidatePack === null ? null : cloneContinuousProductLoopPackVersion(currentState.candidatePack),
+        runtimePlasticity: currentState.runtimePlasticity === null ? null : structuredClone(currentState.runtimePlasticity),
+        promotionAllowed: false,
+        promotionFindings: [],
+        promoted: false
+    };
+    if (!turnResult.eventExport.ok) {
+        learningWarnings.push(`continuous learner skipped: ${turnResult.eventExport.error}`);
+        return {
+            runtimeOwner: "openclaw",
+            compileActiveVersion,
+            compileActivePackId,
+            turn: turnResult,
+            supervision,
+            learning,
+            state: cloneContinuousProductLoopState(currentState)
+        };
+    }
+    const normalizedEventExport = turnResult.eventExport.normalizedEventExport;
+    supervision = buildCanonicalSupervision(normalizedEventExport);
+    learning.supervisionDigest = supervision.supervisionDigest;
+    currentState.lastSupervision = cloneCanonicalSupervision(supervision);
+    const mergedHistory = mergeRuntimeEventHistory(currentState, normalizedEventExport);
+    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,
+            interactionEvents: currentState.interactionEvents,
+            feedbackEvents: currentState.feedbackEvents,
+            learnedRouting: input.learnedRouting ?? true,
+            state: currentState.learner,
+            builtAt: normalizeIsoTimestamp(input.candidateBuiltAt, "candidateBuiltAt", normalizedEventExport.range.lastCreatedAt ?? normalizedEventExport.range.firstCreatedAt),
+            ...(input.offlineArtifacts !== undefined ? { offlineArtifacts: input.offlineArtifacts } : {}),
+            ...(input.structuralOps !== undefined ? { structuralOps: input.structuralOps } : {}),
+            ...(input.sparseFeedback !== undefined ? { sparseFeedback: input.sparseFeedback } : {}),
+            ...(input.liveSliceSize !== undefined ? { liveSliceSize: input.liveSliceSize } : {}),
+            ...(input.backfillSliceSize !== undefined ? { backfillSliceSize: input.backfillSliceSize } : {}),
+            ...(input.cadence !== undefined ? { cadence: input.cadence } : {})
+        });
+        currentState.learner = structuredClone(learnerResult.state);
+        currentState.runtimePlasticity = learnerResult.state.runtimePlasticity === null ? null : structuredClone(learnerResult.state.runtimePlasticity);
+        learning.runtimePlasticity = currentState.runtimePlasticity === null ? null : structuredClone(currentState.runtimePlasticity);
+        learning.bridgeDigest = learnerResult.bridge.bridgeDigest;
+        learning.selectedSliceIds = learnerResult.selectedSlices.map((slice) => slice.sliceId);
+        learning.materializationJobId = learnerResult.materialization?.jobId ?? null;
+        learning.materializationReason = learnerResult.materialization?.reason ?? null;
+        learning.materializationLane = learnerResult.materialization?.lane ?? null;
+        if (learnerResult.materialization !== null) {
+            const candidatePack = registerPackVersion(currentState, buildLearningCandidateTarget(learnerResult.materialization.candidate));
+            const candidateRootDir = buildContinuousPackRoot(loopRoot, candidatePack);
+            const descriptor = materializeAlwaysOnLearningCandidatePack(candidateRootDir, learnerResult.materialization);
+            const candidateTarget = describePackCompileTarget(descriptor);
+            learning.candidateRootDir = candidateRootDir;
+            learning.candidatePack = cloneContinuousProductLoopPackVersion(candidatePack);
+            currentState.candidatePack = cloneContinuousProductLoopPackVersion(candidatePack);
+            const stagedAt = normalizeIsoTimestamp(input.stageUpdatedAt, "stageUpdatedAt", descriptor.manifest.provenance.builtAt);
+            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, {
+                    updatedAt: promotedAt,
+                    reason: `auto_promote:${learnerResult.materialization.reason}:${learnerResult.materialization.lane}`
+                });
+                currentState.promotionCount += 1;
+                currentState.candidatePack = null;
+                learning.promoted = true;
+                const activePack = registerPackVersion(currentState, candidateTarget);
+                currentState.currentActivePack = cloneContinuousProductLoopPackVersion(activePack);
+                currentState.activePackVersion = activePack.version;
+                syncContinuousActivePack(currentState);
+            }
+        }
+    }
+    catch (error) {
+        if (!failOpen) {
+            throw error;
+        }
+        learningWarnings.push(`continuous learner failed open: ${toErrorMessage(error)}`);
+    }
+    return {
+        runtimeOwner: "openclaw",
+        compileActiveVersion,
+        compileActivePackId,
+        turn: turnResult,
+        supervision,
+        learning,
+        state: cloneContinuousProductLoopState(currentState)
+    };
+}
+function ensureRecordedSessionTrace(trace) {
+    if (trace.contract !== RECORDED_SESSION_TRACE_CONTRACT) {
+        throw new Error(`${RECORDED_SESSION_TRACE_CONTRACT} contract is required`);
+    }
+    normalizeNonEmptyString(trace.traceId, "traceId");
+    normalizeIsoTimestamp(trace.recordedAt, "recordedAt");
+    normalizeIsoTimestamp(trace.bundleBuiltAt, "bundleBuiltAt");
+    normalizeNonEmptyString(trace.sessionId, "sessionId");
+    normalizeNonEmptyString(trace.channel, "channel");
+    normalizeNonEmptyString(trace.sourceStream, "sourceStream");
+    normalizeIsoTimestamp(trace.seedBuiltAt, "seedBuiltAt");
+    normalizeIsoTimestamp(trace.seedActivatedAt, "seedActivatedAt");
+    if (trace.privacy.sanitized !== true) {
+        throw new Error("recorded session trace must be explicitly sanitized");
+    }
+    if (trace.seedCues.length === 0) {
+        throw new Error("recorded session trace requires at least one seed cue");
+    }
+    if (trace.turns.length === 0) {
+        throw new Error("recorded session trace requires at least one turn");
+    }
+    for (const [index, cue] of trace.seedCues.entries()) {
+        normalizeNonEmptyString(cue.cueId, `seedCues[${index}].cueId`);
+        normalizeIsoTimestamp(cue.createdAt, `seedCues[${index}].createdAt`);
+        normalizeNonEmptyString(cue.content, `seedCues[${index}].content`);
+    }
+    for (const [index, turn] of trace.turns.entries()) {
+        normalizeIsoTimestamp(turn.createdAt, `turns[${index}].createdAt`);
+        normalizeNonEmptyString(turn.userMessage, `turns[${index}].userMessage`);
+        if ((turn.expectedContextPhrases ?? []).length === 0) {
+            throw new Error(`turns[${index}].expectedContextPhrases must include at least one phrase`);
+        }
+        for (const [feedbackIndex, feedback] of (turn.feedback ?? []).entries()) {
+            normalizeIsoTimestamp(feedback.createdAt, `turns[${index}].feedback[${feedbackIndex}].createdAt`);
+            normalizeNonEmptyString(feedback.content, `turns[${index}].feedback[${feedbackIndex}].content`);
+        }
+    }
+}
+function padReplayNumber(value) {
+    return String(value).padStart(2, "0");
+}
+function replayTurnId(traceId, index, explicitValue) {
+    return normalizeOptionalString(explicitValue) ?? `${traceId}-turn-${padReplayNumber(index + 1)}`;
+}
+function replaySequenceStart(index) {
+    return 1_000 + index * 10;
+}
+function replayMessageId(turnId) {
+    return `msg-${turnId}`;
+}
+function addMinutes(value, minutes) {
+    return new Date(Date.parse(value) + minutes * 60_000).toISOString();
+}
+function normalizeReplayPhrase(value) {
+    return value.toLowerCase().replace(/\s+/gu, " ").trim();
+}
+function hasReplayPhrase(texts, phrase) {
+    const normalizedPhrase = normalizeReplayPhrase(phrase);
+    return texts.some((text) => normalizeReplayPhrase(text).includes(normalizedPhrase));
+}
+function uniqueStringsInOrder(values) {
+    const seen = new Set();
+    const unique = [];
+    for (const value of values) {
+        if (seen.has(value)) {
+            continue;
+        }
+        seen.add(value);
+        unique.push(value);
+    }
+    return unique;
+}
+function buildRecordedSessionSeedExport(trace) {
+    const agentId = normalizeOptionalString(trace.agentId) ?? DEFAULT_AGENT_ID;
+    const seedSessionId = `${trace.sessionId}-seed`;
+    const sourceStream = `${trace.sourceStream}/seed`;
+    const interactionEvents = [];
+    const feedbackEvents = [];
+    let sequence = 1;
+    for (const cue of trace.seedCues) {
+        const interactionEventId = `${seedSessionId}:${cue.cueId}:interaction`;
+        const feedbackEventId = `${seedSessionId}:${cue.cueId}:feedback`;
+        const interaction = createInteractionEvent({
+            eventId: interactionEventId,
+            agentId,
+            sessionId: seedSessionId,
+            channel: trace.channel,
+            sequence,
+            kind: "operator_override",
+            createdAt: cue.createdAt,
+            source: {
+                runtimeOwner: "openclaw",
+                stream: sourceStream
+            },
+            messageId: `${cue.cueId}-seed-message`
+        });
+        sequence += 1;
+        const feedback = createFeedbackEvent({
+            eventId: feedbackEventId,
+            agentId,
+            sessionId: seedSessionId,
+            channel: trace.channel,
+            sequence,
+            kind: cue.kind ?? "teaching",
+            createdAt: addMinutes(cue.createdAt, 1),
+            source: {
+                runtimeOwner: "openclaw",
+                stream: sourceStream
+            },
+            content: cue.content,
+            relatedInteractionId: interaction.eventId
+        });
+        sequence += 1;
+        interactionEvents.push(interaction);
+        feedbackEvents.push(feedback);
+    }
+    return buildNormalizedEventExport({
+        interactionEvents,
+        feedbackEvents
+    });
+}
+function recordedSessionFixtureBase(trace) {
+    const traceHash = checksumJsonPayload(trace);
+    const turns = trace.turns.map((turn, index) => {
+        const turnId = replayTurnId(trace.traceId, index, turn.turnId);
+        const sequenceStart = replaySequenceStart(index);
+        return {
+            turnId,
+            turn: {
+                ...(trace.agentId !== undefined && trace.agentId !== null ? { agentId: trace.agentId } : {}),
+                sessionId: trace.sessionId,
+                channel: trace.channel,
+                sourceStream: trace.sourceStream,
+                userMessage: turn.userMessage,
+                createdAt: turn.createdAt,
+                sequenceStart,
+                maxContextBlocks: 3,
+                mode: "heuristic",
+                ...(turn.runtimeHints !== undefined ? { runtimeHints: [...turn.runtimeHints] } : {}),
+                compile: {
+                    createdAt: turn.createdAt,
+                    sequence: sequenceStart
+                },
+                delivery: turn.deliveredAt === undefined || turn.deliveredAt === null
+                    ? false
+                    : {
+                        createdAt: turn.deliveredAt,
+                        sequence: sequenceStart + 1,
+                        messageId: replayMessageId(turnId)
+                    },
+                feedback: (turn.feedback ?? []).map((feedback, feedbackIndex) => ({
+                    createdAt: feedback.createdAt,
+                    content: feedback.content,
+                    sequence: sequenceStart + 2 + feedbackIndex,
+                    kind: feedback.kind ?? null
+                }))
+            },
+            expectedContextPhrases: [...turn.expectedContextPhrases],
+            minimumPhraseHits: Math.max(1, turn.minimumPhraseHits ?? turn.expectedContextPhrases.length)
+        };
+    });
+    return {
+        contract: RECORDED_SESSION_FIXTURE_CONTRACT,
+        traceId: trace.traceId,
+        source: trace.source,
+        recordedAt: trace.recordedAt,
+        bundleBuiltAt: trace.bundleBuiltAt,
+        traceHash,
+        privacy: {
+            sanitized: true,
+            notes: [...trace.privacy.notes]
+        },
+        workspace: {
+            workspaceId: trace.workspace.workspaceId,
+            snapshotId: trace.workspace.snapshotId,
+            capturedAt: trace.workspace.capturedAt,
+            rootDir: trace.workspace.rootDir,
+            ...(trace.workspace.branch !== undefined ? { branch: trace.workspace.branch } : {}),
+            revision: trace.workspace.revision,
+            ...(trace.workspace.labels !== undefined ? { labels: [...trace.workspace.labels] } : {})
+        },
+        seedBuiltAt: trace.seedBuiltAt,
+        seedActivatedAt: trace.seedActivatedAt,
+        seedExport: buildRecordedSessionSeedExport(trace),
+        turns
+    };
+}
+export function buildRecordedSessionReplayFixture(trace) {
+    ensureRecordedSessionTrace(trace);
+    const base = recordedSessionFixtureBase(trace);
+    return {
+        ...base,
+        fixtureHash: checksumJsonPayload(base)
+    };
+}
+function recordedSessionReplayFixtureBase(fixture) {
+    return {
+        contract: RECORDED_SESSION_FIXTURE_CONTRACT,
+        traceId: fixture.traceId,
+        source: fixture.source,
+        recordedAt: fixture.recordedAt,
+        bundleBuiltAt: fixture.bundleBuiltAt,
+        traceHash: fixture.traceHash,
+        privacy: {
+            sanitized: true,
+            notes: [...fixture.privacy.notes]
+        },
+        workspace: {
+            workspaceId: fixture.workspace.workspaceId,
+            snapshotId: fixture.workspace.snapshotId,
+            capturedAt: fixture.workspace.capturedAt,
+            rootDir: fixture.workspace.rootDir,
+            ...(fixture.workspace.branch !== undefined ? { branch: fixture.workspace.branch } : {}),
+            revision: fixture.workspace.revision,
+            ...(fixture.workspace.labels !== undefined ? { labels: [...fixture.workspace.labels] } : {})
+        },
+        seedBuiltAt: fixture.seedBuiltAt,
+        seedActivatedAt: fixture.seedActivatedAt,
+        seedExport: fixture.seedExport,
+        turns: fixture.turns.map((turn) => ({
+            turnId: turn.turnId,
+            turn: structuredClone(turn.turn),
+            expectedContextPhrases: [...turn.expectedContextPhrases],
+            minimumPhraseHits: turn.minimumPhraseHits
+        }))
+    };
+}
+function buildReplayTurnScore(input) {
+    const phraseHits = input.expectedContextPhrases.filter((phrase) => hasReplayPhrase(input.texts, phrase));
+    const missedPhrases = input.expectedContextPhrases.filter((phrase) => !phraseHits.includes(phrase));
+    const compileScore = input.compileOk ? 40 : 0;
+    const phraseScore = input.expectedContextPhrases.length === 0 ? 60 : Math.round((phraseHits.length / input.expectedContextPhrases.length) * 60);
+    return {
+        phraseHits,
+        missedPhrases,
+        qualityScore: Math.min(100, compileScore + phraseScore)
+    };
+}
+function buildRecordedSessionTurnReport(turnFixture, result, options) {
+    const compileOk = result.ok;
+    const selectedContextTexts = compileOk ? result.compileResponse.selectedContext.map((block) => block.text) : [];
+    const selectedContextIds = compileOk ? result.compileResponse.selectedContext.map((block) => block.id) : [];
+    const scoring = buildReplayTurnScore({
+        compileOk,
+        texts: selectedContextTexts,
+        expectedContextPhrases: turnFixture.expectedContextPhrases
+    });
+    const eventExportDigest = result.eventExport.ok === true ? result.eventExport.normalizedEventExport.provenance.exportDigest : null;
+    return {
+        turnId: turnFixture.turnId,
+        compileOk,
+        fallbackToStaticContext: result.fallbackToStaticContext,
+        hardRequirementViolated: result.hardRequirementViolated,
+        activePackId: result.ok ? result.activePackId : null,
+        usedLearnedRouteFn: result.ok ? result.compileResponse.diagnostics.usedLearnedRouteFn : false,
+        routerIdentity: result.ok ? result.compileResponse.diagnostics.routerIdentity : null,
+        selectionDigest: result.ok ? result.compileResponse.diagnostics.selectionDigest : null,
+        selectedContextIds,
+        selectedContextTexts,
+        eventExportDigest,
+        expectedContextPhrases: [...turnFixture.expectedContextPhrases],
+        minimumPhraseHits: turnFixture.minimumPhraseHits,
+        phraseHits: scoring.phraseHits,
+        missedPhrases: scoring.missedPhrases,
+        qualityScore: scoring.qualityScore,
+        compileActiveVersion: options.compileActiveVersion,
+        promoted: options.promoted,
+        warnings: [...result.warnings]
+    };
+}
+function buildRecordedSessionReplayModeSummary(mode, turns) {
+    const compileOkCount = turns.filter((turn) => turn.compileOk).length;
+    const phraseHitCount = turns.reduce((sum, turn) => sum + turn.phraseHits.length, 0);
+    const phraseCount = turns.reduce((sum, turn) => sum + turn.expectedContextPhrases.length, 0);
+    const usedLearnedRouteTurnCount = turns.filter((turn) => turn.usedLearnedRouteFn).length;
+    const promotionCount = turns.filter((turn) => turn.promoted).length;
+    const qualityScore = turns.length === 0 ? 0 : Math.round(turns.reduce((sum, turn) => sum + turn.qualityScore, 0) / turns.length);
+    const packIds = uniqueStringsInOrder(turns.map((turn) => turn.activePackId).filter(isPresent));
+    const base = {
+        mode,
+        qualityScore,
+        compileOkCount,
+        phraseHitCount,
+        phraseCount,
+        usedLearnedRouteTurnCount,
+        promotionCount,
+        packIds
+    };
+    return {
+        ...base,
+        scoreHash: checksumJsonPayload({
+            summary: base,
+            turns: turns.map((turn) => ({
+                turnId: turn.turnId,
+                qualityScore: turn.qualityScore,
+                phraseHits: turn.phraseHits,
+                missedPhrases: turn.missedPhrases,
+                compileOk: turn.compileOk,
+                usedLearnedRouteFn: turn.usedLearnedRouteFn,
+                activePackId: turn.activePackId,
+                selectionDigest: turn.selectionDigest,
+                promoted: turn.promoted,
+                compileActiveVersion: turn.compileActiveVersion
+            }))
+        })
+    };
+}
+function buildRecordedSessionReplayModeReport(mode, turns) {
+    return {
+        mode,
+        summary: buildRecordedSessionReplayModeSummary(mode, turns),
+        turns: [...turns]
+    };
+}
+function buildRecordedSessionReplayScoreHash(modes) {
+    return checksumJsonPayload(modes.map((mode) => ({
+        mode: mode.mode,
+        qualityScore: mode.summary.qualityScore,
+        compileOkCount: mode.summary.compileOkCount,
+        phraseHitCount: mode.summary.phraseHitCount,
+        phraseCount: mode.summary.phraseCount,
+        usedLearnedRouteTurnCount: mode.summary.usedLearnedRouteTurnCount,
+        promotionCount: mode.summary.promotionCount,
+        packIds: mode.summary.packIds,
+        scoreHash: mode.summary.scoreHash
+    })));
+}
+function recordedSessionReplayBundleBase(bundle) {
+    return {
+        contract: RECORDED_SESSION_BUNDLE_CONTRACT,
+        traceId: bundle.traceId,
+        source: bundle.source,
+        recordedAt: bundle.recordedAt,
+        generatedAt: bundle.generatedAt,
+        traceHash: bundle.traceHash,
+        fixtureHash: bundle.fixtureHash,
+        scoreHash: bundle.scoreHash,
+        privacy: {
+            sanitized: true,
+            notes: [...bundle.privacy.notes]
+        },
+        modes: bundle.modes.map((mode) => ({
+            mode: mode.mode,
+            summary: {
+                ...mode.summary,
+                packIds: [...mode.summary.packIds]
+            },
+            turns: mode.turns.map((turn) => ({
+                ...turn,
+                selectedContextIds: [...turn.selectedContextIds],
+                selectedContextTexts: [...turn.selectedContextTexts],
+                expectedContextPhrases: [...turn.expectedContextPhrases],
+                phraseHits: [...turn.phraseHits],
+                missedPhrases: [...turn.missedPhrases],
+                warnings: [...turn.warnings]
+            }))
+        })),
+        summary: {
+            winnerMode: bundle.summary.winnerMode,
+            ranking: bundle.summary.ranking.map((entry) => ({ ...entry }))
+        }
+    };
+}
+function buildRecordedSessionTurnExportRoot(modeRoot, turnId) {
+    return {
+        rootDir: path.join(modeRoot, "exports", turnId),
+        exportName: turnId
+    };
+}
+function prepareReplayModeRoot(rootDir, mode) {
+    const modeRoot = path.resolve(path.join(rootDir, mode));
+    rmSync(modeRoot, { recursive: true, force: true });
+    mkdirSync(modeRoot, { recursive: true });
+    return modeRoot;
+}
+function prepareSeedActivation(rootDir, fixture) {
+    const activationRoot = path.join(rootDir, "activation");
+    const seedPackRoot = path.join(rootDir, "seed-pack");
+    const seedPack = materializeCandidatePackFromNormalizedEventExport(seedPackRoot, {
+        packLabel: `${fixture.traceId}-seed`,
+        workspace: fixture.workspace,
+        normalizedEventExport: fixture.seedExport,
+        learnedRouting: false,
+        builtAt: fixture.seedBuiltAt,
+        offlineArtifacts: ["recorded-session-replay-seed"],
+        structuralOps: {
+            connect: 1
+        }
+    });
+    activatePack(activationRoot, seedPackRoot, {
+        updatedAt: fixture.seedActivatedAt,
+        reason: "recorded_session_seed_activate"
+    });
+    return {
+        activationRoot,
+        seedPackId: seedPack.manifest.packId
+    };
+}
+function runRecordedSessionNoBrainMode(rootDir, fixture) {
+    const modeRoot = prepareReplayModeRoot(rootDir, "no_brain");
+    const activationRoot = path.join(modeRoot, "activation");
+    const turns = fixture.turns.map((turnFixture) => {
+        const result = runRuntimeTurn({
+            ...turnFixture.turn,
+            export: buildRecordedSessionTurnExportRoot(modeRoot, turnFixture.turnId)
+        }, {
+            activationRoot,
+            failOpen: true
+        });
+        return buildRecordedSessionTurnReport(turnFixture, result, {
+            compileActiveVersion: null,
+            promoted: false
+        });
+    });
+    return buildRecordedSessionReplayModeReport("no_brain", turns);
+}
+function runRecordedSessionSeedPackMode(rootDir, fixture) {
+    const modeRoot = prepareReplayModeRoot(rootDir, "seed_pack");
+    const { activationRoot } = prepareSeedActivation(modeRoot, fixture);
+    const turns = fixture.turns.map((turnFixture) => {
+        const result = runRuntimeTurn({
+            ...turnFixture.turn,
+            export: buildRecordedSessionTurnExportRoot(modeRoot, turnFixture.turnId)
+        }, {
+            activationRoot,
+            failOpen: false
+        });
+        return buildRecordedSessionTurnReport(turnFixture, result, {
+            compileActiveVersion: 1,
+            promoted: false
+        });
+    });
+    return buildRecordedSessionReplayModeReport("seed_pack", turns);
+}
+function runRecordedSessionLearnedReplayMode(rootDir, fixture) {
+    const modeRoot = prepareReplayModeRoot(rootDir, "learned_replay");
+    const { activationRoot } = prepareSeedActivation(modeRoot, fixture);
+    const loopRoot = path.join(modeRoot, "loop");
+    let state;
+    const turns = [];
+    for (const turnFixture of fixture.turns) {
+        const compileCreatedAt = normalizeIsoTimestamp(turnFixture.turn.compile?.createdAt, "turn.compile.createdAt", turnFixture.turn.createdAt);
+        const result = runContinuousProductLoopTurn({
+            activationRoot,
+            loopRoot,
+            packLabel: `${fixture.traceId}-learned`,
+            workspace: fixture.workspace,
+            ...(state !== undefined ? { state } : {}),
+            learnedRouting: true,
+            failOpen: false,
+            turn: {
+                ...turnFixture.turn,
+                export: buildRecordedSessionTurnExportRoot(modeRoot, turnFixture.turnId)
+            },
+            candidateBuiltAt: addMinutes(compileCreatedAt, 2),
+            stageUpdatedAt: addMinutes(compileCreatedAt, 3),
+            promoteUpdatedAt: addMinutes(compileCreatedAt, 4)
+        });
+        state = result.state;
+        turns.push(buildRecordedSessionTurnReport(turnFixture, result.turn, {
+            compileActiveVersion: result.compileActiveVersion,
+            promoted: result.learning.promoted
+        }));
+    }
+    return buildRecordedSessionReplayModeReport("learned_replay", turns);
+}
+export function runRecordedSessionReplay(rootDir, fixture) {
+    const resolvedRoot = path.resolve(normalizeNonEmptyString(rootDir, "rootDir"));
+    const seedExportErrors = validateNormalizedEventExport(fixture.seedExport);
+    if (seedExportErrors.length > 0) {
+        throw new Error(`recorded session replay seed export is invalid: ${seedExportErrors.join("; ")}`);
+    }
+    const expectedFixtureHash = checksumJsonPayload(recordedSessionReplayFixtureBase(fixture));
+    if (fixture.fixtureHash !== expectedFixtureHash) {
+        throw new Error(`recorded session replay fixtureHash mismatch: expected ${expectedFixtureHash}, received ${fixture.fixtureHash}`);
+    }
+    const modes = [
+        runRecordedSessionNoBrainMode(resolvedRoot, fixture),
+        runRecordedSessionSeedPackMode(resolvedRoot, fixture),
+        runRecordedSessionLearnedReplayMode(resolvedRoot, fixture)
+    ];
+    const ranking = modes
+        .map((mode) => ({
+        mode: mode.mode,
+        qualityScore: mode.summary.qualityScore
+    }))
+        .sort((left, right) => right.qualityScore - left.qualityScore || left.mode.localeCompare(right.mode));
+    const scoreHash = buildRecordedSessionReplayScoreHash(modes);
+    const base = {
+        contract: RECORDED_SESSION_BUNDLE_CONTRACT,
+        traceId: fixture.traceId,
+        source: fixture.source,
+        recordedAt: fixture.recordedAt,
+        generatedAt: fixture.bundleBuiltAt,
+        traceHash: fixture.traceHash,
+        fixtureHash: fixture.fixtureHash,
+        scoreHash,
+        privacy: {
+            sanitized: true,
+            notes: [...fixture.privacy.notes]
+        },
+        modes,
+        summary: {
+            winnerMode: ranking[0]?.mode ?? null,
+            ranking
+        }
+    };
+    return {
+        ...base,
+        bundleHash: checksumJsonPayload(base)
+    };
+}
+function rescoreRecordedSessionReplayTurn(turn) {
+    const scoring = buildReplayTurnScore({
+        compileOk: turn.compileOk,
+        texts: turn.selectedContextTexts,
+        expectedContextPhrases: turn.expectedContextPhrases
+    });
+    return {
+        ...turn,
+        phraseHits: scoring.phraseHits,
+        missedPhrases: scoring.missedPhrases,
+        qualityScore: scoring.qualityScore,
+        selectedContextIds: [...turn.selectedContextIds],
+        selectedContextTexts: [...turn.selectedContextTexts],
+        expectedContextPhrases: [...turn.expectedContextPhrases],
+        warnings: [...turn.warnings]
+    };
+}
+function rescoreRecordedSessionReplayMode(mode) {
+    const turns = mode.turns.map((turn) => rescoreRecordedSessionReplayTurn(turn));
+    return buildRecordedSessionReplayModeReport(mode.mode, turns);
+}
+export function rescoreRecordedSessionReplayBundle(bundle) {
+    const modes = bundle.modes.map((mode) => rescoreRecordedSessionReplayMode(mode));
+    return {
+        scoreHash: buildRecordedSessionReplayScoreHash(modes),
+        modes: modes.map((mode) => ({
+            mode: mode.mode,
+            qualityScore: mode.summary.qualityScore,
+            scoreHash: mode.summary.scoreHash
+        }))
+    };
+}
+export function verifyRecordedSessionReplayBundleHashes(bundle) {
+    const rescored = rescoreRecordedSessionReplayBundle(bundle);
+    const rebuiltBundleHash = checksumJsonPayload(recordedSessionReplayBundleBase(bundle));
+    return {
+        bundleHashMatches: rebuiltBundleHash === bundle.bundleHash,
+        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;
+    }
+    return {
+        slot: slot.slot,
+        packId: slot.packId,
+        activationReady: slot.activationReady,
+        routePolicy: slot.routePolicy,
+        routerIdentity: slot.routerIdentity,
+        workspaceSnapshot: slot.workspaceSnapshot,
+        workspaceRevision: slot.workspaceRevision,
+        eventRange: { ...slot.eventRange },
+        eventExportDigest: slot.eventExportDigest,
+        builtAt: slot.builtAt,
+        updatedAt,
+        findings: [...slot.findings]
+    };
+}
+function summarizeLastPromotion(inspection) {
+    if (inspection.active === null) {
+        return {
+            known: false,
+            at: null,
+            confidence: "no_active_pack",
+            note: "active slot is empty, so no promotion can be proven"
+        };
+    }
+    if (inspection.previous !== null) {
+        return {
+            known: inspection.pointers.active?.updatedAt !== null,
+            at: inspection.pointers.active?.updatedAt ?? null,
+            confidence: "proven_from_previous_pointer",
+            note: "previous pointer is retained, so the current active pack is the last promoted pack"
+        };
+    }
+    return {
+        known: false,
+        at: null,
+        confidence: "unknown_from_local_pointers",
+        note: "no previous pointer is retained, so local activation pointers cannot prove the last promotion time"
+    };
+}
+function summarizeCandidateAheadBy(candidateAheadBy) {
+    if (candidateAheadBy === null) {
+        return [];
+    }
+    return Object.entries(candidateAheadBy)
+        .filter(([, changed]) => changed === true)
+        .map(([field]) => field)
+        .sort();
+}
+function isAwaitingFirstExportSlot(slot) {
+    return slot !== null && slot.eventRange.count === 0;
+}
+function summarizeBrainState(active, observability) {
+    if (active === null) {
+        return {
+            state: "no_active_pack",
+            initMode: null,
+            runtimePlasticitySource: null,
+            seedStateVisible: false,
+            seedBlockCount: 0,
+            activePackId: null,
+            activeWorkspaceSnapshot: null,
+            activeEventExportDigest: null,
+            detail: "no active pack is pinned, so the serve path can only fail open or hard fail"
+        };
+    }
+    const state = observability.initHandoff.handoffState;
+    const detail = state === "pg_promoted_pack_authoritative"
+        ? "serving is pinned to a PG-promoted pack rather than seed-state authority"
+        : state === "seed_state_authoritative"
+            ? "serving is still pinned to the current seed-state authority"
+            : "init/handoff metadata is missing for the active pack";
+    return {
+        state,
+        initMode: observability.initHandoff.initMode,
+        runtimePlasticitySource: observability.graphDynamics.runtimePlasticitySource,
+        seedStateVisible: observability.initHandoff.seedStateVisible,
+        seedBlockCount: observability.initHandoff.seedBlockCount,
+        activePackId: active.packId,
+        activeWorkspaceSnapshot: active.workspaceSnapshot,
+        activeEventExportDigest: active.eventExportDigest,
+        detail
+    };
+}
+function summarizeServePath(compile) {
+    if (compile === null) {
+        return {
+            state: "unprobed",
+            fallbackToStaticContext: false,
+            hardRequirementViolated: false,
+            activePackId: null,
+            usedLearnedRouteFn: null,
+            routerIdentity: null,
+            selectionMode: null,
+            refreshStatus: null,
+            freshnessChecksum: null,
+            contextAttribution: buildContextAttributionSummary({
+                fallbackToStaticContext: false,
+                hardRequirementViolated: false,
+                usedLearnedRouteFn: null,
+                unprobed: true
+            }),
+            error: null
+        };
+    }
+    if (!compile.ok) {
+        return {
+            state: compile.hardRequirementViolated ? "hard_fail" : "fail_open_static_context",
+            fallbackToStaticContext: compile.fallbackToStaticContext,
+            hardRequirementViolated: compile.hardRequirementViolated,
+            activePackId: compile.activePackId,
+            usedLearnedRouteFn: compile.usedLearnedRouteFn,
+            routerIdentity: compile.routerIdentity,
+            selectionMode: null,
+            refreshStatus: null,
+            freshnessChecksum: null,
+            contextAttribution: compile.contextAttribution,
+            error: compile.error
+        };
+    }
+    return {
+        state: "serving_active_pack",
+        fallbackToStaticContext: compile.fallbackToStaticContext,
+        hardRequirementViolated: compile.hardRequirementViolated,
+        activePackId: compile.activePackId,
+        usedLearnedRouteFn: compile.usedLearnedRouteFn,
+        routerIdentity: compile.routerIdentity,
+        selectionMode: readDiagnosticNoteValue(compile.notes, "selection_mode="),
+        refreshStatus: readDiagnosticNoteValue(compile.notes, "router_refresh_status="),
+        freshnessChecksum: readDiagnosticNoteValue(compile.notes, "router_freshness_checksum="),
+        contextAttribution: compile.contextAttribution,
+        error: compile.error
+    };
+}
+function loadOperatorEventExport(input) {
+    const eventExportPath = normalizeOptionalString(input.eventExportPath);
+    if (eventExportPath === undefined) {
+        return null;
+    }
+    const resolvedPath = path.resolve(eventExportPath);
+    const stats = statSync(resolvedPath);
+    if (stats.isDirectory()) {
+        const bundle = loadRuntimeEventExportBundle(resolvedPath);
+        return {
+            sourcePath: resolvedPath,
+            sourceKind: "bundle_root",
+            normalizedEventExport: bundle.normalizedEventExport,
+            exportedAt: bundle.manifest.exportedAt
+        };
+    }
+    const normalizedEventExport = readJsonFile(resolvedPath);
+    const validationErrors = validateNormalizedEventExport(normalizedEventExport);
+    if (validationErrors.length > 0) {
+        throw new Error(`normalized event export is invalid: ${validationErrors.join("; ")}`);
+    }
+    return {
+        sourcePath: resolvedPath,
+        sourceKind: "payload",
+        normalizedEventExport,
+        exportedAt: null
+    };
+}
+function summarizeSupervision(input) {
+    const loaded = loadOperatorEventExport(input);
+    if (loaded === null) {
+        return {
+            available: false,
+            sourcePath: null,
+            sourceKind: "missing",
+            exportDigest: null,
+            exportedAt: null,
+            flowing: null,
+            sourceCount: 0,
+            freshestSourceStream: null,
+            freshestCreatedAt: null,
+            freshestKind: null,
+            humanLabelCount: null,
+            sources: [],
+            detail: "no event export path supplied"
+        };
+    }
+    const observability = describeNormalizedEventExportObservability(loaded.normalizedEventExport);
+    const freshestSource = observability.supervisionFreshnessBySource[0] ?? null;
+    const flowing = observability.teacherFreshness.freshestCreatedAt !== null && observability.teacherFreshness.humanLabelCount > 0;
+    return {
+        available: true,
+        sourcePath: loaded.sourcePath,
+        sourceKind: loaded.sourceKind,
+        exportDigest: observability.exportDigest,
+        exportedAt: loaded.exportedAt,
+        flowing,
+        sourceCount: observability.supervisionFreshnessBySource.length,
+        freshestSourceStream: observability.teacherFreshness.sourceStream ?? freshestSource?.sourceStream ?? null,
+        freshestCreatedAt: observability.teacherFreshness.freshestCreatedAt ?? freshestSource?.freshestCreatedAt ?? null,
+        freshestKind: observability.teacherFreshness.freshestKind ?? freshestSource?.freshestKind ?? null,
+        humanLabelCount: observability.teacherFreshness.humanLabelCount,
+        sources: [...observability.teacherFreshness.sources],
+        detail: flowing
+            ? "human supervision is visible in the supplied export"
+            : "the supplied export does not yet show human supervision"
+    };
+}
+function loadTeacherSnapshot(input) {
+    const teacherSnapshotPath = normalizeOptionalString(input.teacherSnapshotPath);
+    if (teacherSnapshotPath === undefined) {
+        return null;
+    }
+    const snapshot = readJsonFile(path.resolve(teacherSnapshotPath));
+    if (snapshot.runtimeOwner !== "openclaw") {
+        throw new Error("teacher snapshot runtimeOwner must be openclaw");
+    }
+    return snapshot;
+}
+function summarizeTeacherLoop(input) {
+    const teacherSnapshotPath = normalizeOptionalString(input.teacherSnapshotPath);
+    if (teacherSnapshotPath === undefined) {
+        return {
+            available: false,
+            sourcePath: null,
+            lastNoOpReason: "unavailable",
+            latestFreshness: "unavailable",
+            lastProcessedAt: null,
+            queueDepth: null,
+            queueCapacity: null,
+            running: null,
+            lastMaterializedPackId: null,
+            notes: [],
+            detail: "no teacher snapshot path supplied"
+        };
+    }
+    const snapshot = loadTeacherSnapshot(input);
+    if (snapshot === null) {
+        return {
+            available: false,
+            sourcePath: path.resolve(teacherSnapshotPath),
+            lastNoOpReason: "unavailable",
+            latestFreshness: "unavailable",
+            lastProcessedAt: null,
+            queueDepth: null,
+            queueCapacity: null,
+            running: null,
+            lastMaterializedPackId: null,
+            notes: [],
+            detail: "teacher snapshot could not be loaded"
+        };
+    }
+    return {
+        available: true,
+        sourcePath: path.resolve(teacherSnapshotPath),
+        lastNoOpReason: snapshot.diagnostics.lastNoOpReason,
+        latestFreshness: snapshot.diagnostics.latestFreshness,
+        lastProcessedAt: snapshot.diagnostics.lastProcessedAt,
+        queueDepth: snapshot.queue.depth,
+        queueCapacity: snapshot.queue.capacity,
+        running: snapshot.queue.running,
+        lastMaterializedPackId: snapshot.learner.lastMaterialization?.candidate.summary.packId ?? null,
+        notes: [...snapshot.diagnostics.notes],
+        detail: "async teacher diagnostics loaded"
+    };
+}
+function summarizeAlwaysOnLearning(input) {
+    const teacherSnapshotPath = normalizeOptionalString(input.teacherSnapshotPath);
+    if (teacherSnapshotPath === undefined) {
+        return {
+            available: false,
+            sourcePath: null,
+            bootstrapped: null,
+            mode: "unavailable",
+            nextPriorityLane: "unavailable",
+            pendingLive: null,
+            pendingBackfill: null,
+            pendingTotal: null,
+            freshLivePriority: null,
+            learnedRange: null,
+            materializationCount: null,
+            lastMaterializedAt: null,
+            lastMaterializationReason: null,
+            lastMaterializationLane: null,
+            lastMaterializationPriority: null,
+            lastMaterializedPackId: null,
+            detail: "no teacher snapshot path supplied"
+        };
+    }
+    const snapshot = loadTeacherSnapshot(input);
+    if (snapshot === null) {
+        return {
+            available: false,
+            sourcePath: path.resolve(teacherSnapshotPath),
+            bootstrapped: null,
+            mode: "unavailable",
+            nextPriorityLane: "unavailable",
+            pendingLive: null,
+            pendingBackfill: null,
+            pendingTotal: null,
+            freshLivePriority: null,
+            learnedRange: null,
+            materializationCount: null,
+            lastMaterializedAt: null,
+            lastMaterializationReason: null,
+            lastMaterializationLane: null,
+            lastMaterializationPriority: null,
+            lastMaterializedPackId: null,
+            detail: "teacher snapshot could not be loaded"
+        };
+    }
+    const plan = describeAlwaysOnLearningRuntimeState(snapshot.learner.state, snapshot.learner.lastMaterialization);
+    return {
+        available: true,
+        sourcePath: path.resolve(teacherSnapshotPath),
+        bootstrapped: plan.bootstrapped,
+        mode: plan.mode,
+        nextPriorityLane: plan.nextPriorityLane,
+        pendingLive: plan.pending.live,
+        pendingBackfill: plan.pending.backfill,
+        pendingTotal: plan.pending.total,
+        freshLivePriority: plan.pending.freshLivePriority,
+        learnedRange: plan.learnedRange === null ? null : { ...plan.learnedRange },
+        materializationCount: plan.materialization.count,
+        lastMaterializedAt: plan.materialization.lastMaterializedAt,
+        lastMaterializationReason: plan.materialization.lastReason,
+        lastMaterializationLane: plan.materialization.lastLane,
+        lastMaterializationPriority: plan.materialization.lastPriority,
+        lastMaterializedPackId: snapshot.learner.lastMaterialization?.candidate.summary.packId ?? null,
+        detail: plan.pending.freshLivePriority
+            ? "fresh live slices remain ahead of passive catch-up"
+            : plan.pending.backfill > 0
+                ? "passive backfill remains queued behind the current live state"
+                : plan.bootstrapped
+                    ? "fast-init has handed off to the current learned export without queued backlog"
+                    : "learner is waiting for the first export"
+    };
+}
+function buildOperatorFindings(report) {
+    const findings = [];
+    const push = (severity, code, summary, detail) => {
+        findings.push({ severity, code, summary, detail });
+    };
+    if (report.active === null) {
+        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) {
+            push("pass", "learned_route_ready", `learned routing is active: ${report.learnedRouting.routerIdentity ?? "unknown-router"}`, `updateCount=${report.learnedRouting.updateCount ?? 0}; labels=${report.learnedRouting.collectedLabelsTotal ?? 0}; handoff=${report.learnedRouting.handoffState}`);
+        }
+        else {
+            push("fail", "learned_route_missing", "active pack requires learned routing but the learned route artifact is unavailable", "repair the router artifact or promote a healthy learned-routing candidate before serving");
+        }
+    }
+    else {
+        push("pass", "learned_route_optional", "active pack does not require learned routing", `handoff=${report.learnedRouting.handoffState}`);
+    }
+    if (report.servePath.state === "serving_active_pack") {
+        push("pass", "serve_path_verified", `serve path compiles from active pack ${report.servePath.activePackId ?? "unknown-pack"}`, `selection=${report.servePath.selectionMode ?? "unknown"}; tiers=${report.servePath.contextAttribution.selectionTiers ?? "unknown"}; router=${report.servePath.routerIdentity ?? "none"}; routeFreshness=${report.servePath.freshnessChecksum ?? "unknown"}`);
+    }
+    else if (report.servePath.state === "fail_open_static_context") {
+        push("warn", "serve_path_fail_open", "serve path would fail open to static context", report.servePath.error ?? "compile probe fell back to static context");
+    }
+    else if (report.servePath.state === "hard_fail") {
+        push("fail", "serve_path_hard_fail", "serve path would hard fail on the learned-routing requirement", report.servePath.error ?? "compile probe violated a learned-routing hard requirement");
+    }
+    else {
+        push("warn", "serve_path_unprobed", "serve path was not probed", "operator surface could not verify fail-open versus hard-fail behavior");
+    }
+    if (report.learnedRouting.required && report.servePath.state === "serving_active_pack" && report.servePath.usedLearnedRouteFn !== true) {
+        push("fail", "serve_path_route_evidence_missing", "serve path compiled without learned-route evidence on a learned-routing pack", `router=${report.servePath.routerIdentity ?? report.learnedRouting.routerIdentity ?? "none"}; selection=${report.servePath.selectionMode ?? "unknown"}`);
+    }
+    if (report.servePath.state === "serving_active_pack") {
+        if (report.servePath.contextAttribution.brainCompiledBlockCount > 0) {
+            push("pass", "brain_context_visible", "serve probe selected brain-compiled context", `brainSources=${formatList(report.servePath.contextAttribution.brainCompiledSources)}; kernelSources=${formatList(report.servePath.contextAttribution.stableKernelSources)}; evidence=${report.servePath.contextAttribution.evidence}`);
+        }
+        else {
+            push("warn", "brain_context_kernel_only", "serve probe stayed inside the stable kernel", `kernelSources=${formatList(report.servePath.contextAttribution.stableKernelSources)}; evidence=${report.servePath.contextAttribution.evidence}; ${report.servePath.contextAttribution.detail}`);
+        }
+    }
+    if (report.candidate === null) {
+        push("pass", "candidate_missing", "no candidate pack is currently staged", "steady state can legitimately run without a staged candidate until the next refresh lands");
+    }
+    else if (!report.candidate.activationReady) {
+        push("warn", "candidate_unhealthy", `candidate slot is not activation-ready: ${report.candidate.packId}`, report.candidate.findings.join("; ") || "fix candidate pack payloads before promotion");
+    }
+    else if (report.promotion.allowed) {
+        push("pass", "promotion_ready", `candidate is promotion-ready: ${report.candidate.packId}`, report.freshness.candidateAheadBy.length === 0
+            ? "candidate is staged and promotion is allowed"
+            : `candidate is ahead on ${report.freshness.candidateAheadBy.join(", ")}`);
+    }
+    else {
+        push("warn", "promotion_blocked", `candidate is staged but promotion is blocked: ${report.candidate.packId}`, report.promotion.findings.join("; ") || "inspect freshness and activation findings before promotion");
+    }
+    if (report.promotion.lastPromotion.known) {
+        push("pass", "last_promotion_known", `last promotion is proven at ${report.promotion.lastPromotion.at}`, report.promotion.lastPromotion.note);
+    }
+    else {
+        push("warn", "last_promotion_unknown", "last promotion is not provable from local activation pointers", report.promotion.lastPromotion.note);
+    }
+    if (report.rollback.allowed) {
+        push("pass", "rollback_ready", `rollback is ready to restore ${report.rollback.previousPackId ?? "the previous pack"}`, report.previous === null ? "previous pack is pointer-visible even if slot inspection is unavailable" : `previous pack=${report.previous.packId}`);
+    }
+    else {
+        push("warn", "rollback_blocked", "rollback is not ready", report.rollback.findings.join("; ") || "previous pointer is missing or no rollback target is retained");
+    }
+    if (!report.supervision.available) {
+        push("warn", "supervision_unavailable", "supervision flow is not inspectable yet", "pass `--event-export <bundle-root-or-payload>` to inspect local supervision freshness");
+    }
+    else if (report.supervision.flowing) {
+        push("pass", "supervision_visible", `supervision is flowing through ${report.supervision.freshestSourceStream ?? "unknown-source"}`, `freshest=${report.supervision.freshestCreatedAt ?? "unknown"}; humanLabels=${report.supervision.humanLabelCount ?? 0}`);
+    }
+    else {
+        push("warn", "supervision_not_flowing", "the supplied export does not yet show human supervision", `sourcePath=${report.supervision.sourcePath ?? "unknown"}; exportDigest=${report.supervision.exportDigest ?? "unknown"}`);
+    }
+    if (!report.teacherLoop.available) {
+        push("warn", "teacher_snapshot_unavailable", "last async no-op reason is not inspectable yet", "pass `--teacher-snapshot <snapshot.json>` to inspect duplicate/no-op handling");
+    }
+    else {
+        push("pass", "teacher_snapshot_loaded", `last async no-op reason is ${report.teacherLoop.lastNoOpReason}`, `latestFreshness=${report.teacherLoop.latestFreshness}; queue=${report.teacherLoop.queueDepth}/${report.teacherLoop.queueCapacity}`);
+    }
+    return findings;
+}
+function summarizeOperatorStatus(findings) {
+    if (findings.some((finding) => finding.severity === "fail")) {
+        return "fail";
+    }
+    if (findings.some((finding) => finding.severity === "warn")) {
+        return "warn";
+    }
+    return "ok";
+}
+function yesNo(value) {
+    if (value === null) {
+        return "unknown";
+    }
+    return value ? "yes" : "no";
+}
+function formatList(values, empty = "none") {
+    return values.length === 0 ? empty : values.join(",");
+}
+function formatCompactList(values, empty = "none", maxItems = 2, maxLength = 20) {
+    if (values.length === 0) {
+        return empty;
+    }
+    const visible = values.slice(0, maxItems).map((value) => formatCompactValue(value, empty, maxLength));
+    return values.length > maxItems ? `${visible.join("|")}+${values.length - maxItems}more` : visible.join("|");
+}
+function formatCompactValue(value, empty = "none", maxLength = 24) {
+    if (value === null || value === undefined || value.length === 0) {
+        return empty;
+    }
+    return value.length <= maxLength ? value : `${value.slice(0, maxLength)}…`;
+}
+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);
+    const observability = describeActivationObservability(activationRoot, "active", {
+        updatedAt
+    });
+    const attachStatus = describeAttachStatus({ activationRoot });
+    const active = summarizeOperatorSlot(inspection.active, inspection.pointers.active?.updatedAt ?? null);
+    const reportBase = {
+        generatedAt: updatedAt,
+        activationRoot,
+        active,
+        candidate: summarizeOperatorSlot(inspection.candidate, inspection.pointers.candidate?.updatedAt ?? null),
+        previous: summarizeOperatorSlot(inspection.previous, inspection.pointers.previous?.updatedAt ?? null),
+        freshness: {
+            activeBehindPromotionReadyCandidate: observability.promotionFreshness.activeBehindPromotionReadyCandidate,
+            candidateAheadBy: summarizeCandidateAheadBy(observability.promotionFreshness.candidateAheadBy)
+        },
+        brain: summarizeBrainState(active, observability),
+        learnedRouting: {
+            required: observability.learnedRouteFn.required,
+            available: observability.learnedRouteFn.available,
+            routerIdentity: observability.learnedRouteFn.routerIdentity,
+            routeFnVersion: observability.learnedRouteFn.routeFnVersion,
+            trainingMethod: observability.learnedRouteFn.trainingMethod,
+            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,
+            updateCount: observability.learnedRouteFn.updateCount,
+            supervisionCount: observability.learnedRouteFn.supervisionCount,
+            collectedLabelsTotal: observability.learnedRouteFn.collectedLabels?.total ?? null,
+            freshnessChecksum: observability.learnedRouteFn.freshnessChecksum,
+            handoffState: observability.initHandoff.handoffState,
+            initMode: observability.initHandoff.initMode,
+            seedStateVisible: observability.initHandoff.seedStateVisible
+        },
+        servePath: summarizeServePath(attachStatus.compile),
+        promotion: {
+            allowed: inspection.promotion.allowed,
+            findings: [...inspection.promotion.findings],
+            lastPromotion: summarizeLastPromotion(inspection),
+            activeUpdatedAt: inspection.pointers.active?.updatedAt ?? null,
+            candidateUpdatedAt: inspection.pointers.candidate?.updatedAt ?? null,
+            previousUpdatedAt: inspection.pointers.previous?.updatedAt ?? null
+        },
+        rollback: {
+            allowed: inspection.rollback.allowed,
+            findings: [...inspection.rollback.findings],
+            previousPackId: inspection.previous?.packId ?? inspection.pointers.previous?.packId ?? null,
+            state: inspection.rollback.allowed ? "ready" : inspection.active === null ? "unknown" : "blocked"
+        },
+        supervision: summarizeSupervision(input),
+        learning: summarizeAlwaysOnLearning(input),
+        teacherLoop: summarizeTeacherLoop(input)
+    };
+    const findings = buildOperatorFindings(reportBase);
+    return {
+        ...reportBase,
+        status: summarizeOperatorStatus(findings),
+        findings
+    };
+}
+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";
+    return [
+        header,
+        `preview     ${yesNo(result.dryRun)} activation=${result.activationRoot} updatedAt=${result.updatedAt}`,
+        `before      active=${result.before.activePackId ?? "none"} candidate=${result.before.candidatePackId ?? "none"} previous=${result.before.previousPackId ?? "none"}`,
+        `after       active=${result.after?.activePackId ?? "none"} candidate=${result.after?.candidatePackId ?? "none"} previous=${result.after?.previousPackId ?? "none"}`,
+        `result      restored=${result.restoredPackId ?? "none"} parkedCandidate=${result.parkedCandidatePackId ?? "none"}`,
+        `findings    ${formatList(result.findings)}`
+    ].join("\n");
+}
+/**
+ * Describes the kernel/brain boundary for a single compile response.
+ *
+ * Combines:
+ * - Brain context summary (from the compile response diagnostics)
+ * - Kernel surface validation (if a surface descriptor is supplied)
+ * - A coverage advisory based on routing signals
+ *
+ * See `docs/kernel-brain-boundary.md` for the full decision framework.
+ */
+export function describeKernelBrainBoundary(compileResponse, surface) {
+    const diag = compileResponse.diagnostics;
+    // Collect the roles of selected blocks.
+    const selectedRoles = [
+        ...new Set(compileResponse.selectedContext
+            .map((b) => b.source)
+            .filter((s) => typeof s === "string" && s.length > 0))
+    ];
+    // Detect whether any block was compacted (compactedFrom set on the block).
+    const compactionApplied = compileResponse.selectedContext.some((b) => Array.isArray(b.compactedFrom) && (b.compactedFrom?.length ?? 0) > 0);
+    // Coverage advisory.
+    // Token match evidence lives in diagnostics.notes as "selection_mode=token_match(...)"
+    // or "selection_tiers=token_match_only" / "selection_tiers=token_match+priority_fallback".
+    const notesStr = diag.notes.join(" ");
+    const hasTokenMatches = notesStr.includes("selection_mode=token_match") ||
+        notesStr.includes("selection_tiers=token_match");
+    let brainCoverageAdvisory;
+    if (diag.usedLearnedRouteFn && hasTokenMatches) {
+        brainCoverageAdvisory = "likely_covered";
+    }
+    else if (hasTokenMatches || diag.usedLearnedRouteFn) {
+        brainCoverageAdvisory = "partial";
+    }
+    else {
+        brainCoverageAdvisory = "likely_gap";
+    }
+    const kernelValidation = surface !== undefined ? validateKernelSurface(surface) : null;
+    return {
+        brain: {
+            packId: compileResponse.packId,
+            mode: diag.modeEffective,
+            selectedBlockCount: compileResponse.selectedContext.length,
+            selectedRoles,
+            usedLearnedRouteFn: diag.usedLearnedRouteFn,
+            compactionApplied
+        },
+        kernelValidation,
+        brainCoverageAdvisory
+    };
+}
 //# sourceMappingURL=index.js.map