@openclawbrain/openclaw 0.1.10 → 0.1.12

package/dist/src/index.js

@@ -1,10 +1,10 @@
 import { createHash } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import process from "node:process";
 import { compileRuntimeFromActivation } from "@openclawbrain/compiler";
 import { CONTRACT_IDS, buildNormalizedEventExport, canonicalJson, checksumJsonPayload, createFeedbackEvent, createInteractionEvent, sortNormalizedEvents, validateKernelSurface, validateNormalizedEventExport } from "@openclawbrain/contracts";
-import { describeNormalizedEventExportObservability } from "@openclawbrain/event-export";
+import { classifyFeedbackSignalContent, 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";
@@ -21,11 +21,14 @@ export const RUNTIME_EVENT_EXPORT_BUNDLE_LAYOUT = {
     manifest: "manifest.json",
     payload: "normalized-event-export.json"
 };
-function normalizeBootstrapProfileSelector(value) {
-    if (value === undefined || value === null || value === "current_profile") {
-        return "current_profile";
+function normalizeRuntimeProfileSelector(value, fieldName, fallback = "current_profile") {
+    if (value === undefined || value === null) {
+        return fallback;
     }
-    throw new Error('bootstrapRuntimeAttach only supports profileSelector="current_profile"');
+    return normalizeNonEmptyString(value, fieldName);
+}
+function normalizeBootstrapProfileSelector(value) {
+    return normalizeRuntimeProfileSelector(value, "profileSelector");
 }
 function quoteShellArg(value) {
     return `'${value.replace(/'/g, `'"'"'`)}'`;
@@ -57,10 +60,13 @@ function buildBootstrapAttachRollbackDryRunCommand(activationRoot) {
     return `${detectBootstrapOperatorCliPrefix()} rollback --activation-root ${quoteShellArg(activationRoot)} --dry-run`;
 }
 function buildBootstrapRuntimeAttachNextSteps(input) {
+    const profileSpecific = input.profileSelector !== "current_profile";
     const nextSteps = [
         {
             id: "inspect_current_profile_status",
-            detail: 'Ask the attached gateway "How\'s the brain?" with the compact current-profile status summary; add --json for the canonical object.',
+            detail: profileSpecific
+                ? `Inspect the canonical current-profile status for this activation root; explicit attach/export attribution for profileSelector="${input.profileSelector}" stays on the runtime path.`
+                : 'Ask the attached gateway "How\'s the brain?" with the compact current-profile status summary; add --json for the canonical object.',
             command: buildBootstrapAttachStatusCommand(input.activationRoot)
         },
         {
@@ -72,14 +78,18 @@ function buildBootstrapRuntimeAttachNextSteps(input) {
     if (input.currentProfile.brainStatus.awaitingFirstExport) {
         nextSteps.push({
             id: "record_next_current_profile_turn",
-            detail: "Export the next live current-profile turn so refresh/promote can advance beyond seed_state_authoritative.",
+            detail: profileSpecific
+                ? `Export the next live turn with profileSelector="${input.profileSelector}" so refresh/promote can advance beyond seed_state_authoritative without widening the operator read scope.`
+                : "Export the next live current-profile turn so refresh/promote can advance beyond seed_state_authoritative.",
             command: null
         });
     }
     else {
         nextSteps.push({
             id: "continue_current_profile_learning_loop",
-            detail: "Keep exporting current-profile turns and refresh/promote newer activation-ready packs off the hot path.",
+            detail: profileSpecific
+                ? `Keep exporting turns with profileSelector="${input.profileSelector}" and refresh/promote newer activation-ready packs off the hot path.`
+                : "Keep exporting current-profile turns and refresh/promote newer activation-ready packs off the hot path.",
             command: null
         });
     }
@@ -87,12 +97,16 @@ function buildBootstrapRuntimeAttachNextSteps(input) {
 }
 export function formatBootstrapRuntimeAttachReport(result) {
     const [nextStep, ...followUps] = result.nextSteps;
+    const profileIdSuffix = result.currentProfile.profile.profileId === null ? "" : ` id=${result.currentProfile.profile.profileId}`;
     const lines = [
         `ATTACH ${result.currentProfile.brainStatus.status}`,
-        `profile     selector=${result.profileSelector} attachment=${result.currentProfile.attachment.state}`,
+        `profile     selector=${result.profileSelector}${profileIdSuffix} attachment=${result.currentProfile.attachment.state} policy=${result.currentProfile.attachment.policyMode} operator_scope=${result.operatorReadScope}`,
         `activation  root=${result.activationRoot}`,
         `brain       pack=${result.packId} state=${result.currentProfile.brain.state} serve=${result.currentProfile.brainStatus.serveState}`
     ];
+    if (result.profileSelector !== "current_profile") {
+        lines.push("boundary    canonical status remains current_profile-only; explicit attached profile attribution stays on the runtime attach/export path");
+    }
     if (nextStep !== undefined) {
         lines.push(`next        ${nextStep.detail}`);
         if (nextStep.command !== null) {
@@ -267,6 +281,7 @@ function buildContinuousTurnExport(turn, loopRoot) {
     const exportSeed = checksumJsonPayload({
         sessionId: turn.sessionId,
         channel: turn.channel,
+        userId: turn.userId ?? null,
         sourceStream: turn.sourceStream ?? null,
         userMessage: turn.userMessage,
         createdAt: turn.createdAt ?? null,
@@ -287,7 +302,9 @@ function buildContinuousTurnExport(turn, loopRoot) {
             .filter((item) => item !== null)
             .map((item) => ({
             content: item.content,
+            actorName: item.actorName ?? null,
             createdAt: item.createdAt ?? null,
+            priorityHint: item.priorityHint ?? null,
             sequence: item.sequence ?? null,
             kind: item.kind ?? null,
             messageId: item.messageId ?? null,
@@ -581,6 +598,129 @@ export class AsyncTeacherLiveLoop {
             reason: null
         };
     }
+    enqueueScannedEventExport(scannedEventExport, options = {}) {
+        const built = buildNormalizedEventExportFromScannedEvents(scannedEventExport);
+        if (!built.ok) {
+            return {
+                accepted: false,
+                exportDigest: null,
+                queueDepth: this.queue.length,
+                notes: [...this.diagnostics.notes],
+                reason: built.reason,
+                warnings: [...built.warnings],
+                error: built.error,
+                scanner: cloneScannerExportManifest(built.scanner)
+            };
+        }
+        const enqueue = this.enqueueNormalizedEventExport(built.normalizedEventExport, {
+            observedAt: options.observedAt ?? built.scanner.producedAt
+        });
+        return {
+            accepted: enqueue.accepted,
+            exportDigest: enqueue.exportDigest,
+            queueDepth: enqueue.queueDepth,
+            notes: [...enqueue.notes],
+            reason: enqueue.reason,
+            warnings: [...built.warnings],
+            error: null,
+            scanner: cloneScannerExportManifest(built.scanner)
+        };
+    }
+    async ingestRuntimeEventExportScannerScan(scan) {
+        if (scan.selected.length === 0) {
+            this.diagnostics.lastNoOpReason = "empty_scan";
+            this.refreshNotes();
+            const snapshot = this.snapshot();
+            return {
+                runtimeOwner: "openclaw",
+                scanRoot: scan.scanRoot,
+                scannedAt: scan.scannedAt,
+                selectedCount: 0,
+                acceptedCount: 0,
+                duplicateCount: 0,
+                droppedCount: 0,
+                liveAcceptedCount: 0,
+                backfillAcceptedCount: 0,
+                duplicateScannerDigestCount: scan.duplicateExportDigests.length,
+                staleSkippedCount: scan.staleSkippedExportDigests.length,
+                invalidBundleCount: scan.invalidBundles.length,
+                noOpReason: "empty_scan",
+                notes: [...snapshot.diagnostics.notes],
+                results: [],
+                snapshot
+            };
+        }
+        const results = [];
+        let acceptedCount = 0;
+        let duplicateCount = 0;
+        let droppedCount = 0;
+        let liveAcceptedCount = 0;
+        let backfillAcceptedCount = 0;
+        for (const hit of scan.selected) {
+            let enqueue = this.enqueueNormalizedEventExport(hit.normalizedEventExport, {
+                observedAt: hit.exportedAt
+            });
+            if (!enqueue.accepted && enqueue.reason === "queue_full") {
+                await this.flush();
+                enqueue = this.enqueueNormalizedEventExport(hit.normalizedEventExport, {
+                    observedAt: hit.exportedAt
+                });
+            }
+            if (enqueue.accepted) {
+                acceptedCount += 1;
+                if (hit.lane === "live") {
+                    liveAcceptedCount += 1;
+                }
+                else {
+                    backfillAcceptedCount += 1;
+                }
+            }
+            else if (enqueue.reason === "duplicate_export") {
+                duplicateCount += 1;
+            }
+            else if (enqueue.reason === "queue_full") {
+                droppedCount += 1;
+            }
+            results.push({
+                lane: hit.lane,
+                exportDigest: hit.exportDigest,
+                exportName: hit.exportName,
+                exportedAt: hit.exportedAt,
+                eventRange: {
+                    start: hit.eventRange.start,
+                    end: hit.eventRange.end,
+                    count: hit.eventRange.count
+                },
+                accepted: enqueue.accepted,
+                queueDepth: enqueue.queueDepth,
+                reason: enqueue.reason
+            });
+        }
+        const snapshot = acceptedCount > 0 ? await this.flush() : this.snapshot();
+        const noOpReason = acceptedCount > 0
+            ? "none"
+            : duplicateCount === scan.selected.length
+                ? "duplicate_exports"
+                : "queue_full";
+        return {
+            runtimeOwner: "openclaw",
+            scanRoot: scan.scanRoot,
+            scannedAt: scan.scannedAt,
+            selectedCount: scan.selected.length,
+            acceptedCount,
+            duplicateCount,
+            droppedCount,
+            liveAcceptedCount,
+            backfillAcceptedCount,
+            duplicateScannerDigestCount: scan.duplicateExportDigests.length,
+            staleSkippedCount: scan.staleSkippedExportDigests.length,
+            invalidBundleCount: scan.invalidBundles.length,
+            noOpReason,
+            notes: [...snapshot.diagnostics.notes],
+            results,
+            snapshot
+        };
+    }
     async flush() {
         await this.ensureDrain();
         return this.snapshot();
@@ -684,6 +824,118 @@ export class AsyncTeacherLiveLoop {
 export function createAsyncTeacherLiveLoop(input) {
     return new AsyncTeacherLiveLoop(input);
 }
+function normalizeScannerStringArray(value, fieldName) {
+    if (!Array.isArray(value)) {
+        throw new Error(`${fieldName} must be an array of strings`);
+    }
+    return value.map((entry, index) => normalizeNonEmptyString(entry, `${fieldName}[${index}]`));
+}
+function normalizeScannerLiveWorkspaceInput(workspace) {
+    const normalized = {
+        workspaceId: normalizeNonEmptyString(workspace.workspaceId, "workspace.workspaceId"),
+        snapshotId: normalizeNonEmptyString(workspace.snapshotId, "workspace.snapshotId"),
+        capturedAt: normalizeIsoTimestamp(workspace.capturedAt, "workspace.capturedAt"),
+        rootDir: path.resolve(normalizeNonEmptyString(workspace.rootDir, "workspace.rootDir")),
+        branch: normalizeOptionalString(workspace.branch) ?? null,
+        revision: normalizeOptionalString(workspace.revision) ?? null,
+        dirty: workspace.dirty === true,
+        manifestDigest: normalizeOptionalString(workspace.manifestDigest) ?? null
+    };
+    if (workspace.labels !== undefined) {
+        normalized.labels = normalizeScannerStringArray(workspace.labels, "workspace.labels");
+    }
+    if (workspace.files !== undefined) {
+        normalized.files = normalizeScannerStringArray(workspace.files, "workspace.files");
+    }
+    return normalized;
+}
+export function scanRecordedSession(input) {
+    const rootDir = path.resolve(normalizeNonEmptyString(input.rootDir, "rootDir"));
+    const fixture = buildRecordedSessionReplayFixture(structuredClone(input.trace));
+    const bundle = runRecordedSessionReplay(rootDir, fixture);
+    return {
+        runtimeOwner: "openclaw",
+        scanMode: "session",
+        rootDir,
+        fixtureHash: fixture.fixtureHash,
+        bundle
+    };
+}
+export function scanLiveEventExport(input) {
+    const normalizedEventExport = structuredClone(input.normalizedEventExport);
+    const validationErrors = validateNormalizedEventExport(normalizedEventExport);
+    if (validationErrors.length > 0) {
+        throw new Error(`normalized event export is invalid: ${validationErrors.join("; ")}`);
+    }
+    const workspace = normalizeScannerLiveWorkspaceInput(input.workspace);
+    const packLabel = normalizeOptionalString(input.packLabel) ?? "scanner-live-cli";
+    const observedAt = normalizeIsoTimestamp(input.observedAt, "observedAt", normalizedEventExport.range.lastCreatedAt ?? normalizedEventExport.range.firstCreatedAt ?? new Date().toISOString());
+    const teacherArtifacts = buildTeacherSupervisionArtifactsFromNormalizedEventExport({
+        normalizedEventExport,
+        observedAt,
+        staleAfterMs: input.staleAfterMs ?? DEFAULT_TEACHER_SUPERVISION_STALE_AFTER_MS
+    });
+    const learnerResult = advanceAlwaysOnLearningRuntime({
+        packLabel,
+        workspace,
+        interactionEvents: normalizedEventExport.interactionEvents,
+        feedbackEvents: normalizedEventExport.feedbackEvents,
+        teacherSupervisionArtifacts: teacherArtifacts,
+        learnedRouting: input.learnedRouting ?? true,
+        state: createAlwaysOnLearningRuntimeState(),
+        builtAt: normalizeIsoTimestamp(input.builtAt, "builtAt", observedAt),
+        ...(input.liveSliceSize !== undefined ? { liveSliceSize: input.liveSliceSize } : {}),
+        ...(input.backfillSliceSize !== undefined ? { backfillSliceSize: input.backfillSliceSize } : {})
+    });
+    const latestFreshness = latestTeacherFreshness(teacherArtifacts);
+    const lastNoOpReason = teacherArtifacts.length === 0 ? "no_teacher_artifacts" : "none";
+    const snapshot = {
+        runtimeOwner: "openclaw",
+        queue: {
+            capacity: 1,
+            depth: 0,
+            running: false
+        },
+        teacher: {
+            artifactCount: teacherArtifacts.length,
+            artifacts: cloneTeacherSupervisionArtifacts(teacherArtifacts),
+            latestFreshness
+        },
+        learner: {
+            state: structuredClone(learnerResult.state),
+            lastMaterialization: cloneAlwaysOnLearningMaterializationJobOrNull(learnerResult.materialization)
+        },
+        diagnostics: {
+            acceptedExportCount: 1,
+            processedExportCount: 1,
+            duplicateExportCount: 0,
+            droppedExportCount: 0,
+            emittedArtifactCount: teacherArtifacts.length,
+            dedupedArtifactCount: 0,
+            lastProcessedAt: observedAt,
+            latestFreshness,
+            lastNoOpReason,
+            notes: buildAsyncTeacherLoopNotes({
+                queueDepth: 0,
+                latestFreshness,
+                artifactCount: teacherArtifacts.length,
+                emittedArtifactCount: teacherArtifacts.length,
+                dedupedArtifactCount: 0,
+                sparseFeedback: learnerResult.state.sparseFeedback,
+                noOpReason: lastNoOpReason,
+                materialization: learnerResult.materialization
+            })
+        }
+    };
+    return {
+        runtimeOwner: "openclaw",
+        scanMode: "live",
+        observedAt,
+        packLabel,
+        supervision: buildCanonicalSupervision(normalizedEventExport),
+        snapshot
+    };
+}
 function readJsonFile(filePath) {
     return JSON.parse(readFileSync(filePath, "utf8"));
 }
@@ -715,7 +967,8 @@ export function buildRuntimeEventExportBundleManifest(input) {
             feedbackCount: input.normalizedEventExport.provenance.feedbackCount,
             sourceStreams: [...input.normalizedEventExport.provenance.sourceStreams],
             contracts: [...input.normalizedEventExport.provenance.contracts]
-        }
+        },
+        ...(input.scanner !== undefined ? { scanner: cloneScannerExportManifestOrNull(input.scanner) } : {})
     };
 }
 export function validateRuntimeEventExportBundleManifest(value, normalizedEventExport) {
@@ -735,6 +988,12 @@ export function validateRuntimeEventExportBundleManifest(value, normalizedEventE
     if (value.payloadDigest.length === 0) {
         errors.push("payloadDigest is required");
     }
+    if (value.scanner !== undefined && value.scanner !== null) {
+        errors.push(...validateScannerExportManifest(value.scanner).map((message) => `scanner ${message}`));
+        if (normalizedEventExport !== undefined && normalizedEventExport.range.count === 0) {
+            errors.push("scanner bundles require at least one exported event");
+        }
+    }
     if (normalizedEventExport !== undefined) {
         const exportErrors = validateNormalizedEventExport(normalizedEventExport);
         if (exportErrors.length > 0) {
@@ -744,7 +1003,8 @@ export function validateRuntimeEventExportBundleManifest(value, normalizedEventE
             exportName: value.exportName,
             exportedAt: value.exportedAt,
             payloadPath: value.payloadPath,
-            normalizedEventExport
+            normalizedEventExport,
+            ...(value.scanner !== undefined ? { scanner: value.scanner } : {})
         });
         if (rebuilt.payloadDigest !== value.payloadDigest) {
             errors.push("event export bundle payloadDigest does not match the supplied normalized event export");
@@ -752,6 +1012,9 @@ export function validateRuntimeEventExportBundleManifest(value, normalizedEventE
         if (canonicalJson(rebuilt.summary) !== canonicalJson(value.summary)) {
             errors.push("event export bundle summary does not match the supplied normalized event export");
         }
+        if (canonicalJson(rebuilt.scanner ?? null) !== canonicalJson(value.scanner ?? null)) {
+            errors.push("event export bundle scanner metadata does not match the supplied normalized event export");
+        }
     }
     return errors;
 }
@@ -773,6 +1036,709 @@ export function loadRuntimeEventExportBundle(rootDir) {
         normalizedEventExport
     };
 }
+function cloneScannerExportManifest(value) {
+    return {
+        scannerId: value.scannerId,
+        lane: value.lane,
+        status: value.status,
+        producedAt: value.producedAt,
+        sourceManifestPath: value.sourceManifestPath,
+        sourceManifestDigest: value.sourceManifestDigest,
+        warnings: [...value.warnings],
+        failures: [...value.failures]
+    };
+}
+function cloneScannerExportManifestOrNull(value) {
+    return value === null ? null : cloneScannerExportManifest(value);
+}
+function validateScannerExportManifest(value) {
+    const errors = [];
+    if (normalizeOptionalString(value.scannerId) === undefined) {
+        errors.push("scannerId is required");
+    }
+    if (normalizeOptionalString(value.lane) === undefined) {
+        errors.push("lane is required");
+    }
+    if (!["complete", "partial", "failed"].includes(value.status)) {
+        errors.push("status must be complete, partial, or failed");
+    }
+    if (Number.isNaN(Date.parse(value.producedAt))) {
+        errors.push("producedAt must be an ISO timestamp");
+    }
+    if (value.sourceManifestPath !== null && normalizeOptionalString(value.sourceManifestPath) === undefined) {
+        errors.push("sourceManifestPath must be null or a non-empty string");
+    }
+    if (value.sourceManifestDigest !== null && normalizeOptionalString(value.sourceManifestDigest) === undefined) {
+        errors.push("sourceManifestDigest must be null or a non-empty string");
+    }
+    if (!Array.isArray(value.warnings) || value.warnings.some((warning) => normalizeOptionalString(warning) === undefined)) {
+        errors.push("warnings must contain only non-empty strings");
+    }
+    if (!Array.isArray(value.failures) || value.failures.some((failure) => normalizeOptionalString(failure) === undefined)) {
+        errors.push("failures must contain only non-empty strings");
+    }
+    if (value.status === "failed" && value.failures.length === 0) {
+        errors.push("failed scanner manifests require at least one failure");
+    }
+    return errors;
+}
+function normalizeScannerExportWarnings(value) {
+    const warnings = new Set();
+    for (const warning of value.warnings) {
+        const normalized = normalizeOptionalString(warning);
+        if (normalized !== undefined) {
+            warnings.add(normalized);
+        }
+    }
+    for (const failure of value.failures) {
+        const normalized = normalizeOptionalString(failure);
+        if (normalized !== undefined) {
+            warnings.add(`scanner_failure:${normalized}`);
+        }
+    }
+    return [...warnings];
+}
+export function buildNormalizedEventExportFromScannedEvents(input) {
+    const scanner = cloneScannerExportManifest(input.scanner);
+    const scannerErrors = validateScannerExportManifest(scanner);
+    if (scannerErrors.length > 0) {
+        return {
+            ok: false,
+            normalizedEventExport: null,
+            scanner,
+            warnings: normalizeScannerExportWarnings(scanner),
+            reason: "invalid_scanner_manifest",
+            error: `scanner manifest is invalid: ${scannerErrors.join("; ")}`
+        };
+    }
+    const eventCount = input.interactionEvents.length + input.feedbackEvents.length;
+    if (eventCount === 0) {
+        return {
+            ok: false,
+            normalizedEventExport: null,
+            scanner,
+            warnings: normalizeScannerExportWarnings(scanner),
+            reason: scanner.status === "failed" ? "scan_failed" : "no_events",
+            error: scanner.status === "failed"
+                ? "scanner failed before producing any interaction or feedback events"
+                : "scanner output did not contain any interaction or feedback events"
+        };
+    }
+    const normalizedEventExport = buildNormalizedEventExport({
+        interactionEvents: [...input.interactionEvents],
+        feedbackEvents: [...input.feedbackEvents]
+    });
+    const exportErrors = validateNormalizedEventExport(normalizedEventExport);
+    if (exportErrors.length > 0) {
+        return {
+            ok: false,
+            normalizedEventExport: null,
+            scanner,
+            warnings: normalizeScannerExportWarnings(scanner),
+            reason: "invalid_scanner_manifest",
+            error: `scanner output produced an invalid normalized event export: ${exportErrors.join("; ")}`
+        };
+    }
+    return {
+        ok: true,
+        normalizedEventExport,
+        scanner,
+        warnings: normalizeScannerExportWarnings(scanner)
+    };
+}
+function writeNormalizedEventExportBundleFiles(input) {
+    const resolvedRoot = path.resolve(input.rootDir);
+    const manifestPath = path.join(resolvedRoot, RUNTIME_EVENT_EXPORT_BUNDLE_LAYOUT.manifest);
+    const payloadPath = path.join(resolvedRoot, input.manifest.payloadPath);
+    mkdirSync(path.dirname(payloadPath), { recursive: true });
+    writeFileSync(payloadPath, canonicalJson(input.normalizedEventExport), "utf8");
+    writeFileSync(manifestPath, canonicalJson(input.manifest), "utf8");
+    const descriptor = loadRuntimeEventExportBundle(resolvedRoot);
+    return {
+        ok: true,
+        wroteBundle: true,
+        normalizedEventExport: descriptor.normalizedEventExport,
+        rootDir: descriptor.rootDir,
+        manifestPath: descriptor.manifestPath,
+        payloadPath: descriptor.payloadPath,
+        manifest: descriptor.manifest
+    };
+}
+const RUNTIME_EVENT_EXPORT_SCANNER_CHECKPOINT_CONTRACT = "runtime_event_export_scanner_checkpoint.v1";
+export const DEFAULT_RUNTIME_EVENT_EXPORT_SCANNER_LIVE_TAIL_BUNDLES = 2;
+export const DEFAULT_RUNTIME_EVENT_EXPORT_SCANNER_BACKFILL_BUNDLES_PER_PASS = 1;
+export const DEFAULT_RUNTIME_EVENT_EXPORT_SCANNER_STALE_HISTORY_MS = 1000 * 60 * 60 * 24 * 7;
+export const DEFAULT_RUNTIME_EVENT_EXPORT_SCANNER_CHECKPOINT_BASENAME = ".openclawbrain-scanner-checkpoint.json";
+function validateRuntimeEventExportScannerBundleCursor(value, fieldName) {
+    const errors = [];
+    if (value.exportDigest.length === 0) {
+        errors.push(`${fieldName}.exportDigest is required`);
+    }
+    if (value.exportName.length === 0) {
+        errors.push(`${fieldName}.exportName is required`);
+    }
+    if (Number.isNaN(Date.parse(value.exportedAt))) {
+        errors.push(`${fieldName}.exportedAt must be an ISO timestamp`);
+    }
+    if (!Number.isInteger(value.eventRange.start) || value.eventRange.start < 0) {
+        errors.push(`${fieldName}.eventRange.start must be a non-negative integer`);
+    }
+    if (!Number.isInteger(value.eventRange.end) || value.eventRange.end < 0) {
+        errors.push(`${fieldName}.eventRange.end must be a non-negative integer`);
+    }
+    if (!Number.isInteger(value.eventRange.count) || value.eventRange.count < 0) {
+        errors.push(`${fieldName}.eventRange.count must be a non-negative integer`);
+    }
+    return errors;
+}
+export function createRuntimeEventExportScannerCheckpoint(input) {
+    return {
+        contract: RUNTIME_EVENT_EXPORT_SCANNER_CHECKPOINT_CONTRACT,
+        runtimeOwner: "openclaw",
+        scanRoot: path.resolve(normalizeNonEmptyString(input.scanRoot, "scanRoot")),
+        updatedAt: normalizeIsoTimestamp(input.updatedAt, "updatedAt", new Date().toISOString()),
+        live: {
+            after: null
+        },
+        backfill: {
+            before: null,
+            exhausted: false,
+            staleBefore: null
+        },
+        processedExportDigests: [],
+        stats: {
+            scanPasses: 0,
+            liveBundlesScanned: 0,
+            backfillBundlesScanned: 0,
+            duplicateBundlesSkipped: 0,
+            staleBundlesSkipped: 0,
+            invalidBundlesSkipped: 0
+        }
+    };
+}
+export function validateRuntimeEventExportScannerCheckpoint(value) {
+    const errors = [];
+    if (value.contract !== RUNTIME_EVENT_EXPORT_SCANNER_CHECKPOINT_CONTRACT) {
+        errors.push("runtime_event_export_scanner_checkpoint.v1 contract is required");
+    }
+    if (value.runtimeOwner !== "openclaw") {
+        errors.push("runtime event export scanner checkpoint runtimeOwner must be openclaw");
+    }
+    if (value.scanRoot.length === 0) {
+        errors.push("runtime event export scanner checkpoint scanRoot is required");
+    }
+    if (Number.isNaN(Date.parse(value.updatedAt))) {
+        errors.push("runtime event export scanner checkpoint updatedAt must be an ISO timestamp");
+    }
+    if (value.live.after !== null) {
+        errors.push(...validateRuntimeEventExportScannerBundleCursor(value.live.after, "live.after"));
+    }
+    if (value.backfill.before !== null) {
+        errors.push(...validateRuntimeEventExportScannerBundleCursor(value.backfill.before, "backfill.before"));
+    }
+    if (value.backfill.staleBefore !== null && Number.isNaN(Date.parse(value.backfill.staleBefore))) {
+        errors.push("runtime event export scanner checkpoint backfill.staleBefore must be null or an ISO timestamp");
+    }
+    if (new Set(value.processedExportDigests).size !== value.processedExportDigests.length) {
+        errors.push("runtime event export scanner checkpoint processedExportDigests must be unique");
+    }
+    for (const [label, count] of Object.entries(value.stats)) {
+        if (!Number.isInteger(count) || count < 0) {
+            errors.push(`runtime event export scanner checkpoint stats.${label} must be a non-negative integer`);
+        }
+    }
+    return errors;
+}
+export function loadRuntimeEventExportScannerCheckpoint(checkpointPath) {
+    const resolvedPath = path.resolve(normalizeNonEmptyString(checkpointPath, "checkpointPath"));
+    const checkpoint = readJsonFile(resolvedPath);
+    const errors = validateRuntimeEventExportScannerCheckpoint(checkpoint);
+    if (errors.length > 0) {
+        throw new Error(`runtime event export scanner checkpoint is invalid: ${errors.join("; ")}`);
+    }
+    return structuredClone(checkpoint);
+}
+function writeRuntimeEventExportScannerCheckpoint(checkpointPath, checkpoint) {
+    const resolvedPath = path.resolve(checkpointPath);
+    const errors = validateRuntimeEventExportScannerCheckpoint(checkpoint);
+    if (errors.length > 0) {
+        throw new Error(`runtime event export scanner checkpoint is invalid: ${errors.join("; ")}`);
+    }
+    mkdirSync(path.dirname(resolvedPath), { recursive: true });
+    writeFileSync(resolvedPath, canonicalJson(checkpoint), "utf8");
+}
+function normalizePositiveInteger(value, fieldName, fallbackValue) {
+    const resolved = value ?? fallbackValue;
+    if (!Number.isInteger(resolved) || resolved <= 0) {
+        throw new Error(`${fieldName} must be a positive integer`);
+    }
+    return resolved;
+}
+function normalizeNonNegativeDurationMs(value, fieldName, fallbackValue) {
+    const resolved = value ?? fallbackValue;
+    if (!Number.isInteger(resolved) || resolved < 0) {
+        throw new Error(`${fieldName} must be a non-negative integer`);
+    }
+    return resolved;
+}
+function buildRuntimeEventExportScannerBundleCursor(descriptor) {
+    return {
+        exportDigest: descriptor.normalizedEventExport.provenance.exportDigest,
+        exportName: descriptor.manifest.exportName,
+        exportedAt: descriptor.manifest.exportedAt,
+        eventRange: {
+            start: descriptor.normalizedEventExport.range.start,
+            end: descriptor.normalizedEventExport.range.end,
+            count: descriptor.normalizedEventExport.range.count
+        }
+    };
+}
+function compareRuntimeEventExportScannerBundleCursor(left, right) {
+    if (left.eventRange.end !== right.eventRange.end) {
+        return left.eventRange.end - right.eventRange.end;
+    }
+    if (left.eventRange.start !== right.eventRange.start) {
+        return left.eventRange.start - right.eventRange.start;
+    }
+    if (left.exportedAt !== right.exportedAt) {
+        return left.exportedAt.localeCompare(right.exportedAt);
+    }
+    return left.exportDigest.localeCompare(right.exportDigest);
+}
+function buildRuntimeEventExportScannerHit(bundle, queueEntry) {
+    return {
+        lane: queueEntry.lane,
+        rootDir: queueEntry.rootDir,
+        exportDigest: queueEntry.exportDigest,
+        exportName: queueEntry.exportName,
+        exportedAt: queueEntry.exportedAt,
+        eventRange: {
+            start: queueEntry.eventRange.start,
+            end: queueEntry.eventRange.end,
+            count: queueEntry.eventRange.count
+        },
+        priorityBucket: queueEntry.priorityBucket,
+        priorityScore: queueEntry.priorityScore,
+        priorityReasons: [...queueEntry.priorityReasons],
+        humanLabelCount: queueEntry.humanLabelCount,
+        feedbackCount: queueEntry.feedbackCount,
+        teacherRoles: [...queueEntry.teacherRoles],
+        teacherAuthorities: [...queueEntry.teacherAuthorities],
+        priorityClasses: [...queueEntry.priorityClasses],
+        scopedPrincipalEventCount: queueEntry.scopedPrincipalEventCount,
+        supersedingPrincipalEventCount: queueEntry.supersedingPrincipalEventCount,
+        staleHistory: queueEntry.staleHistory,
+        ageMsFromLatest: queueEntry.ageMsFromLatest,
+        normalizedEventExport: structuredClone(bundle.descriptor.normalizedEventExport)
+    };
+}
+function scannerTeacherRoleWeight(role) {
+    switch (role) {
+        case "principal":
+            return 4;
+        case "admin":
+            return 3;
+        case "operator":
+            return 1.5;
+        case "user":
+        case "assistant":
+        case "system":
+        default:
+            return 0;
+    }
+}
+function scannerTeacherAuthorityWeight(authority) {
+    switch (authority) {
+        case "binding":
+            return 4;
+        case "primary_human":
+            return 3;
+        case "high":
+            return 2;
+        case "normal":
+            return 0.5;
+        case "background":
+        default:
+            return 0;
+    }
+}
+function scannerPrincipalPriorityWeight(priorityClass) {
+    switch (priorityClass) {
+        case "critical":
+            return 4;
+        case "high":
+            return 3;
+        case "normal":
+            return 1;
+        case "low":
+        default:
+            return 0;
+    }
+}
+function scannerFeedbackPriorityWeight(kind) {
+    switch (kind) {
+        case "correction":
+            return 5;
+        case "teaching":
+            return 4;
+        case "approval":
+            return 2;
+        case "suppression":
+        default:
+            return 1;
+    }
+}
+function isPrincipalHeavyScannerBundle(learningSurface) {
+    return (learningSurface.principalSummary.teacherRoles.some((role) => role === "principal" || role === "admin") ||
+        learningSurface.principalSummary.teacherAuthorities.some((authority) => authority === "binding" || authority === "primary_human" || authority === "high") ||
+        learningSurface.principalSummary.priorityClasses.some((priorityClass) => priorityClass === "critical" || priorityClass === "high") ||
+        learningSurface.principalSummary.supersedingEventCount > 0);
+}
+function buildRuntimeEventExportScannerQueueEntry(input) {
+    const learningSurface = input.bundle.descriptor.normalizedEventExport.provenance.learningSurface;
+    const ageMsFromLatest = input.latestExportedAt === null ? null : Math.max(0, Date.parse(input.latestExportedAt) - Date.parse(input.bundle.cursor.exportedAt));
+    const recencyScore = ageMsFromLatest === null ? 0 : roundMetric(clamp(3 - ageMsFromLatest / 86_400_000, 0, 3));
+    const feedbackScore = input.bundle.descriptor.normalizedEventExport.feedbackEvents.reduce((sum, event) => sum + scannerFeedbackPriorityWeight(event.kind), 0);
+    const roleScore = learningSurface.principalSummary.teacherRoles.reduce((sum, role) => sum + scannerTeacherRoleWeight(role), 0);
+    const authorityScore = learningSurface.principalSummary.teacherAuthorities.reduce((sum, authority) => sum + scannerTeacherAuthorityWeight(authority), 0);
+    const priorityClassScore = learningSurface.principalSummary.priorityClasses.reduce((sum, priorityClass) => sum + scannerPrincipalPriorityWeight(priorityClass), 0);
+    const principalHeavy = isPrincipalHeavyScannerBundle(learningSurface);
+    const staleHistory = input.staleBefore !== null && input.bundle.cursor.exportedAt < input.staleBefore;
+    const priorityBucket = staleHistory
+        ? "stale_history"
+        : input.lane === "live"
+            ? "live"
+            : principalHeavy
+                ? "principal_backfill"
+                : "backfill";
+    const priorityScore = roundMetric(feedbackScore +
+        roleScore +
+        authorityScore +
+        priorityClassScore +
+        learningSurface.principalSummary.scopedEventCount +
+        learningSurface.principalSummary.supersedingEventCount * 3 +
+        learningSurface.labelHarvest.humanLabels +
+        recencyScore +
+        (principalHeavy ? 6 : 0));
+    const priorityReasons = [];
+    if (input.lane === "live") {
+        priorityReasons.push("live_tail");
+    }
+    if (principalHeavy) {
+        priorityReasons.push("principal_heavy");
+    }
+    for (const role of learningSurface.principalSummary.teacherRoles) {
+        if (role === "principal" || role === "admin") {
+            priorityReasons.push(`teacher_role=${role}`);
+        }
+    }
+    for (const authority of learningSurface.principalSummary.teacherAuthorities) {
+        if (authority === "binding" || authority === "primary_human" || authority === "high") {
+            priorityReasons.push(`teacher_authority=${authority}`);
+        }
+    }
+    for (const priorityClass of learningSurface.principalSummary.priorityClasses) {
+        if (priorityClass === "critical" || priorityClass === "high") {
+            priorityReasons.push(`priority_class=${priorityClass}`);
+        }
+    }
+    if (learningSurface.principalSummary.supersedingEventCount > 0) {
+        priorityReasons.push(`superseding_events=${learningSurface.principalSummary.supersedingEventCount}`);
+    }
+    if (learningSurface.labelHarvest.humanLabels > 0) {
+        priorityReasons.push(`human_labels=${learningSurface.labelHarvest.humanLabels}`);
+    }
+    if (staleHistory) {
+        priorityReasons.push("stale_history_floor");
+    }
+    return {
+        lane: input.lane,
+        rootDir: input.bundle.descriptor.rootDir,
+        exportDigest: input.bundle.cursor.exportDigest,
+        exportName: input.bundle.cursor.exportName,
+        exportedAt: input.bundle.cursor.exportedAt,
+        eventRange: {
+            start: input.bundle.cursor.eventRange.start,
+            end: input.bundle.cursor.eventRange.end,
+            count: input.bundle.cursor.eventRange.count
+        },
+        priorityBucket,
+        priorityScore,
+        priorityReasons,
+        humanLabelCount: learningSurface.labelHarvest.humanLabels,
+        feedbackCount: input.bundle.descriptor.normalizedEventExport.feedbackEvents.length,
+        teacherRoles: [...learningSurface.principalSummary.teacherRoles],
+        teacherAuthorities: [...learningSurface.principalSummary.teacherAuthorities],
+        priorityClasses: [...learningSurface.principalSummary.priorityClasses],
+        scopedPrincipalEventCount: learningSurface.principalSummary.scopedEventCount,
+        supersedingPrincipalEventCount: learningSurface.principalSummary.supersedingEventCount,
+        staleHistory,
+        ageMsFromLatest
+    };
+}
+function compareRuntimeEventExportScannerQueueEntry(left, right) {
+    const bucketOrder = {
+        live: 0,
+        principal_backfill: 1,
+        backfill: 2,
+        stale_history: 3
+    };
+    if (bucketOrder[left.priorityBucket] !== bucketOrder[right.priorityBucket]) {
+        return bucketOrder[left.priorityBucket] - bucketOrder[right.priorityBucket];
+    }
+    if (right.priorityScore !== left.priorityScore) {
+        return right.priorityScore - left.priorityScore;
+    }
+    if (right.eventRange.end !== left.eventRange.end) {
+        return right.eventRange.end - left.eventRange.end;
+    }
+    if (right.eventRange.start !== left.eventRange.start) {
+        return right.eventRange.start - left.eventRange.start;
+    }
+    if (right.exportedAt !== left.exportedAt) {
+        return right.exportedAt.localeCompare(left.exportedAt);
+    }
+    return right.exportDigest.localeCompare(left.exportDigest);
+}
+function listRuntimeEventExportBundleRoots(scanRoot) {
+    if (!existsSync(scanRoot)) {
+        return [];
+    }
+    return readdirSync(scanRoot, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => path.join(scanRoot, entry.name))
+        .sort((left, right) => left.localeCompare(right));
+}
+function discoverRuntimeEventExportBundles(scanRoot) {
+    const loaded = [];
+    const invalidBundles = [];
+    for (const rootDir of listRuntimeEventExportBundleRoots(scanRoot)) {
+        try {
+            const descriptor = loadRuntimeEventExportBundle(rootDir);
+            loaded.push({
+                descriptor,
+                cursor: buildRuntimeEventExportScannerBundleCursor(descriptor)
+            });
+        }
+        catch (error) {
+            invalidBundles.push({
+                rootDir,
+                error: toErrorMessage(error)
+            });
+        }
+    }
+    loaded.sort((left, right) => compareRuntimeEventExportScannerBundleCursor(left.cursor, right.cursor));
+    const deduped = [];
+    const seenDigests = new Set();
+    const duplicateExportDigests = [];
+    for (const bundle of loaded) {
+        if (seenDigests.has(bundle.cursor.exportDigest)) {
+            duplicateExportDigests.push(bundle.cursor.exportDigest);
+            continue;
+        }
+        seenDigests.add(bundle.cursor.exportDigest);
+        deduped.push(bundle);
+    }
+    return {
+        bundles: deduped,
+        invalidBundles,
+        duplicateExportDigests: [...new Set(duplicateExportDigests)]
+    };
+}
+function delayRuntimeEventExportScannerPoll(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+export class RuntimeEventExportScanner {
+    scanRoot;
+    checkpointPath;
+    liveTailBundles;
+    backfillBundlesPerPass;
+    staleHistoryMs;
+    checkpoint;
+    constructor(input) {
+        this.scanRoot = path.resolve(normalizeNonEmptyString(input.scanRoot, "scanRoot"));
+        this.checkpointPath = path.resolve(input.checkpointPath ?? path.join(this.scanRoot, DEFAULT_RUNTIME_EVENT_EXPORT_SCANNER_CHECKPOINT_BASENAME));
+        this.liveTailBundles = normalizePositiveInteger(input.liveTailBundles, "liveTailBundles", DEFAULT_RUNTIME_EVENT_EXPORT_SCANNER_LIVE_TAIL_BUNDLES);
+        this.backfillBundlesPerPass = normalizePositiveInteger(input.backfillBundlesPerPass, "backfillBundlesPerPass", DEFAULT_RUNTIME_EVENT_EXPORT_SCANNER_BACKFILL_BUNDLES_PER_PASS);
+        this.staleHistoryMs = normalizeNonNegativeDurationMs(input.staleHistoryMs, "staleHistoryMs", DEFAULT_RUNTIME_EVENT_EXPORT_SCANNER_STALE_HISTORY_MS);
+        this.checkpoint = existsSync(this.checkpointPath)
+            ? loadRuntimeEventExportScannerCheckpoint(this.checkpointPath)
+            : createRuntimeEventExportScannerCheckpoint({ scanRoot: this.scanRoot });
+        if (this.checkpoint.scanRoot !== this.scanRoot) {
+            throw new Error(`runtime event export scanner checkpoint scanRoot mismatch: checkpoint=${this.checkpoint.scanRoot} scanner=${this.scanRoot}`);
+        }
+    }
+    snapshot() {
+        return structuredClone(this.checkpoint);
+    }
+    scanOnce(options = {}) {
+        const scannedAt = normalizeIsoTimestamp(options.scannedAt, "scannedAt", new Date().toISOString());
+        const discovered = discoverRuntimeEventExportBundles(this.scanRoot);
+        const processedDigests = new Set(this.checkpoint.processedExportDigests);
+        const latestExportedAt = discovered.bundles[discovered.bundles.length - 1]?.cursor.exportedAt ?? null;
+        const staleBefore = latestExportedAt === null ? null : new Date(Date.parse(latestExportedAt) - this.staleHistoryMs).toISOString();
+        const staleSkipped = new Set();
+        const isFreshEnough = (bundle) => {
+            if (staleBefore === null) {
+                return true;
+            }
+            return bundle.cursor.exportedAt >= staleBefore;
+        };
+        const live = this.checkpoint.live.after === null
+            ? discovered.bundles.filter((bundle) => !processedDigests.has(bundle.cursor.exportDigest) && isFreshEnough(bundle)).slice(-this.liveTailBundles)
+            : discovered.bundles
+                .filter((bundle) => !processedDigests.has(bundle.cursor.exportDigest) &&
+                compareRuntimeEventExportScannerBundleCursor(bundle.cursor, this.checkpoint.live.after) > 0 &&
+                isFreshEnough(bundle))
+                .slice(0, this.liveTailBundles);
+        const liveQueue = live.map((bundle) => buildRuntimeEventExportScannerQueueEntry({
+            lane: "live",
+            bundle,
+            latestExportedAt,
+            staleBefore
+        }));
+        const nextLiveAfter = live.length > 0 ? live[live.length - 1]?.cursor ?? null : this.checkpoint.live.after;
+        const backfillFrontier = nextLiveAfter;
+        const liveDigests = new Set(live.map((bundle) => bundle.cursor.exportDigest));
+        const prioritizedBackfillCandidates = [];
+        const staleHistoryQueue = [];
+        for (const bundle of discovered.bundles) {
+            if (processedDigests.has(bundle.cursor.exportDigest) || liveDigests.has(bundle.cursor.exportDigest)) {
+                continue;
+            }
+            const queueEntry = buildRuntimeEventExportScannerQueueEntry({
+                lane: "backfill",
+                bundle,
+                latestExportedAt,
+                staleBefore
+            });
+            if (queueEntry.staleHistory) {
+                staleHistoryQueue.push(queueEntry);
+                staleSkipped.add(bundle.cursor.exportDigest);
+                processedDigests.add(bundle.cursor.exportDigest);
+                continue;
+            }
+            if (backfillFrontier !== null &&
+                compareRuntimeEventExportScannerBundleCursor(bundle.cursor, backfillFrontier) < 0) {
+                prioritizedBackfillCandidates.push({
+                    bundle,
+                    queueEntry
+                });
+            }
+        }
+        prioritizedBackfillCandidates.sort((left, right) => compareRuntimeEventExportScannerQueueEntry(left.queueEntry, right.queueEntry));
+        const selectedBackfillCandidates = prioritizedBackfillCandidates.slice(0, this.backfillBundlesPerPass);
+        const backfill = selectedBackfillCandidates.map((candidate) => candidate.bundle);
+        for (const bundle of [...live, ...backfill]) {
+            processedDigests.add(bundle.cursor.exportDigest);
+        }
+        const backfillQueue = prioritizedBackfillCandidates.map((candidate) => candidate.queueEntry);
+        const selectedLive = liveQueue.map((queueEntry, index) => buildRuntimeEventExportScannerHit(live[index], queueEntry));
+        const selectedBackfill = selectedBackfillCandidates.map((candidate) => buildRuntimeEventExportScannerHit(candidate.bundle, candidate.queueEntry));
+        const nextBackfillBefore = backfill.length > 0
+            ? [...backfill].sort((left, right) => compareRuntimeEventExportScannerBundleCursor(left.cursor, right.cursor))[0]?.cursor ?? null
+            : this.checkpoint.backfill.before;
+        const exhausted = backfillFrontier === null
+            ? true
+            : !prioritizedBackfillCandidates.some((candidate) => !processedDigests.has(candidate.bundle.cursor.exportDigest));
+        this.checkpoint = {
+            contract: RUNTIME_EVENT_EXPORT_SCANNER_CHECKPOINT_CONTRACT,
+            runtimeOwner: "openclaw",
+            scanRoot: this.scanRoot,
+            updatedAt: scannedAt,
+            live: {
+                after: nextLiveAfter === null ? null : { ...nextLiveAfter, eventRange: { ...nextLiveAfter.eventRange } }
+            },
+            backfill: {
+                before: nextBackfillBefore === null ? null : { ...nextBackfillBefore, eventRange: { ...nextBackfillBefore.eventRange } },
+                exhausted,
+                staleBefore
+            },
+            processedExportDigests: [...processedDigests],
+            stats: {
+                scanPasses: this.checkpoint.stats.scanPasses + 1,
+                liveBundlesScanned: this.checkpoint.stats.liveBundlesScanned + selectedLive.length,
+                backfillBundlesScanned: this.checkpoint.stats.backfillBundlesScanned + selectedBackfill.length,
+                duplicateBundlesSkipped: this.checkpoint.stats.duplicateBundlesSkipped + discovered.duplicateExportDigests.length,
+                staleBundlesSkipped: this.checkpoint.stats.staleBundlesSkipped + staleSkipped.size,
+                invalidBundlesSkipped: this.checkpoint.stats.invalidBundlesSkipped + discovered.invalidBundles.length
+            }
+        };
+        writeRuntimeEventExportScannerCheckpoint(this.checkpointPath, this.checkpoint);
+        return {
+            runtimeOwner: "openclaw",
+            scanRoot: this.scanRoot,
+            checkpointPath: this.checkpointPath,
+            scannedAt,
+            live: selectedLive,
+            backfill: selectedBackfill,
+            selected: [...selectedLive, ...selectedBackfill],
+            queue: {
+                ageFloor: {
+                    newestExportedAt: latestExportedAt,
+                    staleBefore,
+                    staleHistoryMs: this.staleHistoryMs
+                },
+                live: liveQueue,
+                backfill: backfillQueue,
+                staleHistory: staleHistoryQueue.sort(compareRuntimeEventExportScannerQueueEntry)
+            },
+            duplicateExportDigests: discovered.duplicateExportDigests,
+            staleSkippedExportDigests: [...staleSkipped],
+            invalidBundles: discovered.invalidBundles,
+            idle: selectedLive.length === 0 && selectedBackfill.length === 0,
+            checkpoint: this.snapshot()
+        };
+    }
+    async runLoop(options = {}) {
+        const pollIntervalMs = normalizeNonNegativeDurationMs(options.pollIntervalMs, "pollIntervalMs", 0);
+        const maxPasses = normalizePositiveInteger(options.maxPasses, "maxPasses", 1);
+        const stopWhenIdle = options.stopWhenIdle !== false;
+        let passCount = 0;
+        let liveBundlesScanned = 0;
+        let backfillBundlesScanned = 0;
+        let lastScan = null;
+        let stoppedReason = "max_passes";
+        while (passCount < maxPasses) {
+            if (options.signal?.aborted) {
+                stoppedReason = "aborted";
+                break;
+            }
+            lastScan = this.scanOnce();
+            passCount += 1;
+            liveBundlesScanned += lastScan.live.length;
+            backfillBundlesScanned += lastScan.backfill.length;
+            if (options.onPass !== undefined) {
+                await options.onPass(lastScan);
+            }
+            if (stopWhenIdle && lastScan.idle) {
+                stoppedReason = "idle";
+                break;
+            }
+            if (passCount >= maxPasses) {
+                stoppedReason = "max_passes";
+                break;
+            }
+            if (pollIntervalMs > 0) {
+                await delayRuntimeEventExportScannerPoll(pollIntervalMs);
+            }
+        }
+        return {
+            runtimeOwner: "openclaw",
+            passCount,
+            liveBundlesScanned,
+            backfillBundlesScanned,
+            stoppedReason,
+            lastScan,
+            checkpoint: this.snapshot()
+        };
+    }
+}
+export function createRuntimeEventExportScanner(input) {
+    return new RuntimeEventExportScanner(input);
+}
 function normalizeNonEmptyString(value, fieldName) {
     if (typeof value !== "string" || value.trim().length === 0) {
         throw new Error(`${fieldName} is required`);
@@ -836,23 +1802,134 @@ function isFeedbackKind(value) {
 function isPresent(value) {
     return value !== null;
 }
-export function classifyFeedbackKind(content) {
-    const normalized = content.trim().toLowerCase();
-    if (normalized.length === 0) {
-        return "teaching";
+const KNOWN_SCANNER_REALITY_PRINCIPALS = {
+    bihua: {
+        teacherIdentity: "bihua",
+        teacherRole: "principal",
+        teacherAuthority: "binding",
+        priorityClass: "critical"
+    },
+    jonathan: {
+        teacherIdentity: "jonathan",
+        teacherRole: "admin",
+        teacherAuthority: "high",
+        priorityClass: "high"
+    },
+    "jonathan gu": {
+        teacherIdentity: "jonathan",
+        teacherRole: "admin",
+        teacherAuthority: "high",
+        priorityClass: "high"
     }
-    if (/\b(stop|suppress|mute|silence|pause|don't send|do not send)\b/u.test(normalized)) {
-        return "suppression";
+};
+function normalizePrincipalPriorityHint(value, fieldName) {
+    if (value === undefined || value === null) {
+        return undefined;
     }
-    if (/\b(approved|approve|looks good|ship it|exactly right|that works)\b/u.test(normalized)) {
-        return "approval";
+    if (value === "critical" || value === "high" || value === "normal" || value === "low") {
+        return value;
     }
-    if (/\b(wrong|incorrect|correction|not right|do this instead|not x[, ]+y)\b/u.test(normalized) ||
-        normalized.startsWith("no") ||
-        normalized.startsWith("wrong")) {
-        return "correction";
+    throw new Error(`${fieldName} must be critical, high, normal, or low`);
+}
+function normalizePrincipalActorName(value) {
+    const normalized = normalizeOptionalString(value);
+    return normalized === undefined ? undefined : normalized.toLowerCase().replace(/\s+/gu, " ");
+}
+function slugifyPrincipalIdentityFragment(value) {
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/gu, "-")
+        .replace(/^-+|-+$/gu, "");
+}
+function buildRuntimePrincipalScope(input) {
+    const scopeKey = [
+        `profile:${input.profileSelector}`,
+        input.profileId === undefined ? null : `profile_id:${input.profileId}`,
+        `session:${input.sessionId}`,
+        input.userId === undefined ? null : `user:${input.userId}`,
+        input.interactionId === undefined ? null : `interaction:${input.interactionId}`,
+        input.messageId === undefined ? null : `message:${input.messageId}`
+    ]
+        .filter(isPresent)
+        .join("|");
+    if (input.messageId !== undefined) {
+        return {
+            kind: "message",
+            profileSelector: input.profileSelector,
+            sessionId: input.sessionId,
+            ...(input.interactionId === undefined ? {} : { interactionId: input.interactionId }),
+            messageId: input.messageId,
+            scopeKey
+        };
     }
-    return "teaching";
+    if (input.interactionId !== undefined) {
+        return {
+            kind: "interaction",
+            profileSelector: input.profileSelector,
+            sessionId: input.sessionId,
+            interactionId: input.interactionId,
+            scopeKey
+        };
+    }
+    return {
+        kind: "session",
+        profileSelector: input.profileSelector,
+        sessionId: input.sessionId,
+        scopeKey
+    };
+}
+function buildRuntimeSelfPrincipal(turn) {
+    const profileSelector = normalizeRuntimeProfileSelector(turn.profileSelector, "profileSelector");
+    const profileId = normalizeOptionalString(turn.profileId);
+    const userId = normalizeOptionalString(turn.userId);
+    return {
+        teacherIdentity: "openclaw/self",
+        teacherRole: "assistant",
+        teacherAuthority: "background",
+        priorityClass: "low",
+        principalScope: buildRuntimePrincipalScope({
+            profileSelector,
+            ...(profileId === undefined ? {} : { profileId }),
+            sessionId: turn.sessionId,
+            ...(userId === undefined ? {} : { userId })
+        })
+    };
+}
+function resolveRuntimeFeedbackPrincipal(input) {
+    const actorName = normalizePrincipalActorName(input.feedback.actorName);
+    const knownPrincipal = actorName === undefined ? undefined : KNOWN_SCANNER_REALITY_PRINCIPALS[actorName];
+    const profileSelector = normalizeRuntimeProfileSelector(input.turn.profileSelector, "profileSelector");
+    const profileId = normalizeOptionalString(input.turn.profileId);
+    const userId = normalizeOptionalString(input.turn.userId);
+    const priorityHint = normalizePrincipalPriorityHint(input.feedback.priorityHint, "feedback.priorityHint");
+    const userIdentityFragment = userId === undefined ? undefined : slugifyPrincipalIdentityFragment(userId);
+    const actorIdentityFragment = actorName === undefined ? undefined : slugifyPrincipalIdentityFragment(actorName);
+    const teacherIdentity = knownPrincipal?.teacherIdentity ??
+        (userIdentityFragment === undefined || userIdentityFragment.length === 0
+            ? actorIdentityFragment === undefined || actorIdentityFragment.length === 0
+                ? undefined
+                : `scanner/actor/${actorIdentityFragment}`
+            : `scanner/user/${userIdentityFragment}`);
+    if (teacherIdentity === undefined) {
+        return undefined;
+    }
+    return {
+        teacherIdentity,
+        teacherRole: knownPrincipal?.teacherRole ?? "user",
+        teacherAuthority: knownPrincipal?.teacherAuthority ?? "normal",
+        priorityClass: priorityHint ?? knownPrincipal?.priorityClass ?? "normal",
+        principalScope: buildRuntimePrincipalScope({
+            profileSelector,
+            ...(profileId === undefined ? {} : { profileId }),
+            sessionId: input.turn.sessionId,
+            ...(userId === undefined ? {} : { userId }),
+            ...(input.relatedInteractionId === undefined ? {} : { interactionId: input.relatedInteractionId }),
+            ...(input.messageId === undefined ? {} : { messageId: input.messageId })
+        })
+    };
+}
+export function classifyFeedbackKind(content) {
+    return classifyFeedbackSignalContent(content)?.kind ?? "teaching";
 }
 export function formatPromptContext(compileResponse) {
     const lines = [
@@ -910,6 +1987,222 @@ function classifyCompileFailure(error, activationRoot) {
     }
     return failOpenCompileResult(error, resolvedActivationRoot);
 }
+function uniqueNotes(notes) {
+    return [...new Set(notes.filter((note) => note.length > 0))];
+}
+function roundMetric(value) {
+    return Math.round(value * 100) / 100;
+}
+function clamp(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+function clampInteger(value, minimum, maximum) {
+    return Math.min(maximum, Math.max(minimum, Math.round(value)));
+}
+export function deriveEmpiricalStructuralBudget(input) {
+    const requestedStrategy = input.requestedStrategy ?? "fixed_v1";
+    const defaultMaxContextBlocks = input.defaultMaxContextBlocks ?? 4;
+    const minimumMaxContextBlocks = input.minimumMaxContextBlocks ?? 2;
+    const maximumMaxContextBlocks = input.maximumMaxContextBlocks ?? 6;
+    if (input.requestedMaxContextBlocks !== undefined) {
+        const maxContextBlocks = clampInteger(input.requestedMaxContextBlocks, 0, Number.MAX_SAFE_INTEGER);
+        return {
+            requestedStrategy,
+            effectiveStrategy: requestedStrategy,
+            maxContextBlocks,
+            defaultMaxContextBlocks,
+            evidence: { split: 0, merge: 0, prune: 0, connect: 0 },
+            evidenceTotal: 0,
+            tendencies: { split: 0, merge: 0, prune: 0, connect: 0 },
+            notes: [
+                `requested_budget_strategy=${requestedStrategy}`,
+                `requested_max_context_blocks=${maxContextBlocks}`,
+                `resolved_budget_strategy=${requestedStrategy}`,
+                `resolved_max_context_blocks=${maxContextBlocks}`,
+                "structural_budget_source=caller_override"
+            ]
+        };
+    }
+    if (requestedStrategy !== "empirical_v1") {
+        return {
+            requestedStrategy,
+            effectiveStrategy: requestedStrategy,
+            maxContextBlocks: defaultMaxContextBlocks,
+            defaultMaxContextBlocks,
+            evidence: { split: 0, merge: 0, prune: 0, connect: 0 },
+            evidenceTotal: 0,
+            tendencies: { split: 0, merge: 0, prune: 0, connect: 0 },
+            notes: [
+                `requested_budget_strategy=${requestedStrategy}`,
+                `resolved_budget_strategy=${requestedStrategy}`,
+                `resolved_max_context_blocks=${defaultMaxContextBlocks}`,
+                `structural_budget_source=${requestedStrategy === "fixed_v1" ? "fixed_default" : "fixed_fallback"}`
+            ]
+        };
+    }
+    const evidence = {
+        split: Math.max(0, input.evolution?.structuralOps.split ?? 0),
+        merge: Math.max(0, input.evolution?.structuralOps.merge ?? 0),
+        prune: Math.max(0, Math.max(input.evolution?.structuralOps.prune ?? 0, input.evolution?.prunedBlockIds.length ?? 0)),
+        connect: Math.max(0, input.evolution?.structuralOps.connect ?? 0)
+    };
+    const evidenceTotal = evidence.split + evidence.merge + evidence.prune + evidence.connect;
+    if (evidenceTotal === 0) {
+        return {
+            requestedStrategy,
+            effectiveStrategy: "fixed_v1",
+            maxContextBlocks: defaultMaxContextBlocks,
+            defaultMaxContextBlocks,
+            evidence,
+            evidenceTotal,
+            tendencies: { split: 0, merge: 0, prune: 0, connect: 0 },
+            notes: [
+                `requested_budget_strategy=${requestedStrategy}`,
+                "resolved_budget_strategy=fixed_v1",
+                `resolved_max_context_blocks=${defaultMaxContextBlocks}`,
+                "structural_budget_source=no_evidence_fallback"
+            ]
+        };
+    }
+    const tendencies = {
+        split: evidence.split / evidenceTotal,
+        merge: evidence.merge / evidenceTotal,
+        prune: evidence.prune / evidenceTotal,
+        connect: evidence.connect / evidenceTotal
+    };
+    const expansionPressure = tendencies.split + tendencies.connect;
+    const contractionPressure = tendencies.merge + tendencies.prune;
+    const directionalPressure = expansionPressure - contractionPressure;
+    const maxContextBlocks = clampInteger(defaultMaxContextBlocks + directionalPressure * 2, minimumMaxContextBlocks, maximumMaxContextBlocks);
+    return {
+        requestedStrategy,
+        effectiveStrategy: requestedStrategy,
+        maxContextBlocks,
+        defaultMaxContextBlocks,
+        evidence,
+        evidenceTotal,
+        tendencies,
+        notes: [
+            `requested_budget_strategy=${requestedStrategy}`,
+            `resolved_budget_strategy=${requestedStrategy}`,
+            `resolved_max_context_blocks=${maxContextBlocks}`,
+            "structural_budget_source=graph_evolution_empirical_v1",
+            `structural_budget_evidence=split:${evidence.split},merge:${evidence.merge},prune:${evidence.prune},connect:${evidence.connect},total:${evidenceTotal}`,
+            `structural_budget_tendencies=split:${tendencies.split.toFixed(4)},merge:${tendencies.merge.toFixed(4)},prune:${tendencies.prune.toFixed(4)},connect:${tendencies.connect.toFixed(4)}`,
+            `structural_budget_pressures=expand:${expansionPressure.toFixed(4)},contract:${contractionPressure.toFixed(4)},directional:${directionalPressure.toFixed(4)}`
+        ]
+    };
+}
+export function deriveEmpiricalStructuralBudgetFromCompileSignals(input) {
+    const requestedStrategy = input.requestedStrategy ?? "fixed_v1";
+    const defaultMaxContextBlocks = input.defaultMaxContextBlocks ?? 4;
+    const minimumMaxContextBlocks = input.minimumMaxContextBlocks ?? 2;
+    const maximumMaxContextBlocks = input.maximumMaxContextBlocks ?? 6;
+    if (input.requestedMaxContextBlocks !== undefined) {
+        const maxContextBlocks = clampInteger(input.requestedMaxContextBlocks, 0, Number.MAX_SAFE_INTEGER);
+        return {
+            requestedStrategy,
+            effectiveStrategy: requestedStrategy,
+            maxContextBlocks,
+            defaultMaxContextBlocks,
+            evidence: { split: 0, merge: 0, prune: 0, connect: 0 },
+            evidenceTotal: 0,
+            tendencies: { split: 0, merge: 0, prune: 0, connect: 0 },
+            notes: [
+                `requested_budget_strategy=${requestedStrategy}`,
+                `requested_max_context_blocks=${maxContextBlocks}`,
+                `resolved_budget_strategy=${requestedStrategy}`,
+                `resolved_max_context_blocks=${maxContextBlocks}`,
+                "structural_budget_source=caller_override"
+            ]
+        };
+    }
+    if (requestedStrategy !== "empirical_v1") {
+        return {
+            requestedStrategy,
+            effectiveStrategy: requestedStrategy,
+            maxContextBlocks: defaultMaxContextBlocks,
+            defaultMaxContextBlocks,
+            evidence: { split: 0, merge: 0, prune: 0, connect: 0 },
+            evidenceTotal: 0,
+            tendencies: { split: 0, merge: 0, prune: 0, connect: 0 },
+            notes: [
+                `requested_budget_strategy=${requestedStrategy}`,
+                `resolved_budget_strategy=${requestedStrategy}`,
+                `resolved_max_context_blocks=${defaultMaxContextBlocks}`,
+                `structural_budget_source=${requestedStrategy === "fixed_v1" ? "fixed_default" : "fixed_fallback"}`
+            ]
+        };
+    }
+    const compileEvidence = {
+        expansionCandidates: Math.max(0, (input.structuralSignals?.matchedCandidateCount ?? 0) - (input.structuralSignals?.selectedMatchedCount ?? 0)),
+        traversalActivations: Math.max(0, input.structuralSignals?.traversalActivatedCount ?? 0),
+        overlapPruned: Math.max(0, input.structuralSignals?.overlapPrunedCount ?? 0)
+    };
+    const evidence = {
+        split: compileEvidence.expansionCandidates,
+        merge: 0,
+        prune: compileEvidence.overlapPruned,
+        connect: compileEvidence.traversalActivations
+    };
+    const evidenceTotal = evidence.split + evidence.merge + evidence.prune + evidence.connect;
+    if (evidenceTotal === 0) {
+        return {
+            requestedStrategy,
+            effectiveStrategy: "fixed_v1",
+            maxContextBlocks: defaultMaxContextBlocks,
+            defaultMaxContextBlocks,
+            evidence,
+            evidenceTotal,
+            tendencies: { split: 0, merge: 0, prune: 0, connect: 0 },
+            notes: [
+                `requested_budget_strategy=${requestedStrategy}`,
+                "resolved_budget_strategy=fixed_v1",
+                `resolved_max_context_blocks=${defaultMaxContextBlocks}`,
+                "structural_budget_source=no_compile_signal_evidence_fallback"
+            ]
+        };
+    }
+    const tendencies = {
+        split: evidence.split / evidenceTotal,
+        merge: 0,
+        prune: evidence.prune / evidenceTotal,
+        connect: evidence.connect / evidenceTotal
+    };
+    const expansionPressure = tendencies.split + tendencies.connect;
+    const contractionPressure = tendencies.prune;
+    const directionalPressure = expansionPressure - contractionPressure;
+    const maxContextBlocks = clampInteger(defaultMaxContextBlocks + directionalPressure * 2, minimumMaxContextBlocks, maximumMaxContextBlocks);
+    return {
+        requestedStrategy,
+        effectiveStrategy: requestedStrategy,
+        maxContextBlocks,
+        defaultMaxContextBlocks,
+        evidence,
+        evidenceTotal,
+        tendencies,
+        notes: [
+            `requested_budget_strategy=${requestedStrategy}`,
+            `resolved_budget_strategy=${requestedStrategy}`,
+            `resolved_max_context_blocks=${maxContextBlocks}`,
+            "structural_budget_source=compile_structural_signals_empirical_v1",
+            `structural_budget_compile_evidence=matched_unselected:${compileEvidence.expansionCandidates},traversal:${compileEvidence.traversalActivations},overlap_pruned:${compileEvidence.overlapPruned},total:${evidenceTotal}`,
+            `structural_budget_tendencies=split:${tendencies.split.toFixed(4)},merge:${tendencies.merge.toFixed(4)},prune:${tendencies.prune.toFixed(4)},connect:${tendencies.connect.toFixed(4)}`,
+            `structural_budget_pressures=expand:${expansionPressure.toFixed(4)},contract:${contractionPressure.toFixed(4)},directional:${directionalPressure.toFixed(4)}`
+        ]
+    };
+}
+function resolveCompileBudget(target, input) {
+    const pack = loadPackFromActivation(target.activationRoot, "active");
+    return deriveEmpiricalStructuralBudget({
+        requestedStrategy: input.budgetStrategy ?? "empirical_v1",
+        ...(input.maxContextBlocks !== undefined ? { requestedMaxContextBlocks: input.maxContextBlocks } : {}),
+        ...(pack?.graph.evolution !== undefined ? { evolution: pack.graph.evolution } : {}),
+        defaultMaxContextBlocks: 4,
+        minimumMaxContextBlocks: 2,
+        maximumMaxContextBlocks: 6
+    });
+}
 export function resolveActivePackForCompile(activationRoot) {
     const resolvedActivationRoot = path.resolve(normalizeNonEmptyString(activationRoot, "activationRoot"));
     const inspection = inspectActivationState(resolvedActivationRoot);
@@ -932,11 +2225,12 @@ export function compileRuntimeContext(input) {
     const runtimeHints = normalizeRuntimeHints(input.runtimeHints);
     try {
         const target = resolveActivePackForCompile(activationRoot);
+        const resolvedBudget = resolveCompileBudget(target, input);
         const compile = compileRuntimeFromActivation(activationRoot, {
             contract: CONTRACT_IDS.runtimeCompile,
             agentId,
             userMessage: normalizeNonEmptyString(input.message, "message"),
-            maxContextBlocks: normalizeNonNegativeInteger(input.maxContextBlocks, "maxContextBlocks", 4),
+            maxContextBlocks: resolvedBudget.maxContextBlocks,
             ...(input.maxContextChars !== undefined
                 ? { maxContextChars: normalizeNonNegativeInteger(input.maxContextChars, "maxContextChars", input.maxContextChars) }
                 : {}),
@@ -949,7 +2243,7 @@ export function compileRuntimeContext(input) {
             ...compile.response,
             diagnostics: {
                 ...compile.response.diagnostics,
-                notes: [...compile.response.diagnostics.notes, "OpenClaw remains the runtime owner"]
+                notes: uniqueNotes([...compile.response.diagnostics.notes, ...resolvedBudget.notes, "OpenClaw remains the runtime owner"])
             }
         };
         return {
@@ -981,6 +2275,97 @@ function readDiagnosticNoteList(notes, prefix) {
         .map((entry) => entry.trim())
         .filter((entry) => entry.length > 0);
 }
+function parseDiagnosticInteger(value) {
+    if (value === null) {
+        return null;
+    }
+    const parsed = Number.parseInt(value, 10);
+    return Number.isInteger(parsed) ? parsed : null;
+}
+function parseStructuralBudgetStrategy(value) {
+    return value === "fixed_v1" || value === "empirical_v1" ? value : null;
+}
+function summarizeStructuralDecisionFromNotes(notes) {
+    const requestedBudgetStrategy = parseStructuralBudgetStrategy(readDiagnosticNoteValue(notes, "requested_budget_strategy="));
+    const resolvedBudgetStrategy = parseStructuralBudgetStrategy(readDiagnosticNoteValue(notes, "resolved_budget_strategy="));
+    const resolvedMaxContextBlocks = parseDiagnosticInteger(readDiagnosticNoteValue(notes, "resolved_max_context_blocks="));
+    const requestedMaxContextBlocks = parseDiagnosticInteger(readDiagnosticNoteValue(notes, "requested_max_context_blocks="));
+    const structuralBudgetSource = readDiagnosticNoteValue(notes, "structural_budget_source=");
+    switch (structuralBudgetSource) {
+        case "caller_override":
+            return {
+                origin: "manual_caller_shape",
+                basis: "caller_override",
+                requestedBudgetStrategy,
+                resolvedBudgetStrategy,
+                resolvedMaxContextBlocks,
+                detail: `manual caller shaping fixed the serve-path structural budget at ${requestedMaxContextBlocks ?? resolvedMaxContextBlocks ?? "unknown"} blocks; empirical and default-path control were bypassed`
+            };
+        case "compile_structural_signals_empirical_v1":
+            return {
+                origin: "empirical_control",
+                basis: "compile_structural_signals",
+                requestedBudgetStrategy,
+                resolvedBudgetStrategy,
+                resolvedMaxContextBlocks,
+                detail: `empirical control resolved the serve-path structural budget to ${resolvedMaxContextBlocks ?? "unknown"} blocks from prior compile structural signals; no manual caller shaping was applied`
+            };
+        case "graph_evolution_empirical_v1":
+            return {
+                origin: "empirical_control",
+                basis: "graph_evolution",
+                requestedBudgetStrategy,
+                resolvedBudgetStrategy,
+                resolvedMaxContextBlocks,
+                detail: `empirical control resolved the serve-path structural budget to ${resolvedMaxContextBlocks ?? "unknown"} blocks from active-pack graph evolution evidence; no manual caller shaping was applied`
+            };
+        case "fixed_default":
+            return {
+                origin: "default_path_control",
+                basis: "fixed_default",
+                requestedBudgetStrategy,
+                resolvedBudgetStrategy,
+                resolvedMaxContextBlocks,
+                detail: `default-path fixed-budget control set the serve-path structural budget to ${resolvedMaxContextBlocks ?? "unknown"} blocks because empirical control was not requested`
+            };
+        case "fixed_fallback":
+            return {
+                origin: "default_path_control",
+                basis: "fixed_fallback",
+                requestedBudgetStrategy,
+                resolvedBudgetStrategy,
+                resolvedMaxContextBlocks,
+                detail: `default-path fixed-budget fallback set the serve-path structural budget to ${resolvedMaxContextBlocks ?? "unknown"} blocks; no manual caller shaping was applied`
+            };
+        case "no_evidence_fallback":
+            return {
+                origin: "default_path_control",
+                basis: "no_evidence_fallback",
+                requestedBudgetStrategy,
+                resolvedBudgetStrategy,
+                resolvedMaxContextBlocks,
+                detail: `default-path fixed-budget fallback kept the serve-path structural budget at ${resolvedMaxContextBlocks ?? "unknown"} blocks because graph-evolution evidence was absent`
+            };
+        case "no_compile_signal_evidence_fallback":
+            return {
+                origin: "default_path_control",
+                basis: "no_compile_signal_evidence_fallback",
+                requestedBudgetStrategy,
+                resolvedBudgetStrategy,
+                resolvedMaxContextBlocks,
+                detail: `default-path fixed-budget fallback kept the serve-path structural budget at ${resolvedMaxContextBlocks ?? "unknown"} blocks because compile-signal evidence was absent`
+            };
+        default:
+            return {
+                origin: "unknown",
+                basis: "unknown",
+                requestedBudgetStrategy,
+                resolvedBudgetStrategy,
+                resolvedMaxContextBlocks,
+                detail: "structural decision attribution is unavailable from the compile notes"
+            };
+    }
+}
 function sortedUniqueStrings(values) {
     return [...new Set(values.filter((value) => value.length > 0))].sort((left, right) => left.localeCompare(right));
 }
@@ -1147,6 +2532,7 @@ function buildAttachStatusCompileInput(activationRoot, compile) {
         agentId: normalizeOptionalString(compile?.agentId) ?? `${DEFAULT_AGENT_ID}-attach-status`,
         message: normalizeOptionalString(compile?.message) ?? DEFAULT_ATTACH_STATUS_MESSAGE,
         ...(compile?.maxContextBlocks !== undefined ? { maxContextBlocks: compile.maxContextBlocks } : {}),
+        ...(compile?.budgetStrategy !== undefined ? { budgetStrategy: compile.budgetStrategy } : {}),
         ...(compile?.maxContextChars !== undefined ? { maxContextChars: compile.maxContextChars } : {}),
         ...(compile?.mode !== undefined ? { mode: compile.mode } : {}),
         ...(compile?.compactionMode !== undefined ? { compactionMode: compile.compactionMode } : {}),
@@ -1315,11 +2701,14 @@ export function bootstrapRuntimeAttach(input) {
     });
     const currentProfile = describeCurrentProfileBrainStatus({
         activationRoot,
-        updatedAt: activatedAt
+        updatedAt: activatedAt,
+        ...(input.brainAttachmentPolicy !== undefined ? { brainAttachmentPolicy: input.brainAttachmentPolicy } : {}),
+        ...(input.profileId !== undefined ? { profileId: input.profileId } : {})
     });
     return {
         runtimeOwner: "openclaw",
         profileSelector,
+        operatorReadScope: "current_profile_only",
         activationRoot,
         packRoot,
         packId: descriptor.manifest.packId,
@@ -1328,12 +2717,80 @@ export function bootstrapRuntimeAttach(input) {
         currentProfile,
         nextSteps: buildBootstrapRuntimeAttachNextSteps({
             activationRoot,
+            profileSelector,
             currentProfile
         })
     };
 }
+function normalizeFingerprintEntries(values) {
+    return uniqueStringsInOrder((values ?? [])
+        .map((value) => normalizeOptionalString(value))
+        .filter((value) => value !== undefined));
+}
+function buildRuntimeContextFingerprint(input) {
+    const promptContextFingerprints = normalizeFingerprintEntries(input.turn.contextFingerprint?.promptContextFingerprints);
+    const workspaceInjectionSurfaceDigest = input.turn.contextFingerprint?.workspaceInjectionSurface === undefined ||
+        input.turn.contextFingerprint?.workspaceInjectionSurface === null
+        ? null
+        : checksumJsonPayload(input.turn.contextFingerprint.workspaceInjectionSurface);
+    const promptContextDigest = promptContextFingerprints.length === 0 && workspaceInjectionSurfaceDigest === null
+        ? null
+        : checksumJsonPayload({
+            promptContextFingerprints,
+            workspaceInjectionSurfaceDigest
+        });
+    const runtimeHints = normalizeFingerprintEntries(input.turn.runtimeHints);
+    const runtimeHintsDigest = runtimeHints.length === 0 ? null : checksumJsonPayload(runtimeHints);
+    const profileId = normalizeOptionalString(input.turn.profileId);
+    const profileLineage = uniqueStringsInOrder([
+        "host:openclaw",
+        `profile:${input.profileSelector}`,
+        profileId === undefined ? undefined : `profile_id:${profileId}`,
+        `attachment_policy:${input.brainAttachmentPolicy}`,
+        ...normalizeFingerprintEntries(input.turn.contextFingerprint?.profileLineage)
+    ].filter((value) => value !== undefined));
+    const sessionLineage = uniqueStringsInOrder([
+        `session:${input.turn.sessionId}`,
+        `channel:${input.turn.channel}`,
+        `source_stream:${input.sourceStream}`,
+        ...normalizeFingerprintEntries(input.turn.contextFingerprint?.sessionLineage)
+    ]);
+    const brainLineage = uniqueStringsInOrder([
+        `brain_status:${input.brainStatus}`,
+        `active_pack:${input.activePackId ?? "none"}`,
+        `router:${input.routerIdentity ?? "none"}`,
+        `used_learned_route_fn:${input.usedLearnedRouteFn === null ? "unknown" : String(input.usedLearnedRouteFn)}`
+    ]);
+    const profileLineageDigest = checksumJsonPayload(profileLineage);
+    const sessionLineageDigest = checksumJsonPayload(sessionLineage);
+    const brainLineageDigest = checksumJsonPayload(brainLineage);
+    return {
+        selectionDigest: input.selectionDigest,
+        promptContextDigest,
+        promptContextFingerprints,
+        workspaceInjectionSurfaceDigest,
+        runtimeHintsDigest,
+        runtimeHints,
+        profileLineageDigest,
+        profileLineage,
+        sessionLineageDigest,
+        sessionLineage,
+        brainLineageDigest,
+        brainLineage,
+        digest: checksumJsonPayload({
+            selectionDigest: input.selectionDigest,
+            promptContextDigest,
+            runtimeHintsDigest,
+            profileLineageDigest,
+            sessionLineageDigest,
+            brainLineageDigest
+        })
+    };
+}
 function buildRuntimeTurnAttribution(input) {
+    const profileSelector = normalizeRuntimeProfileSelector(input.turn.profileSelector, "profileSelector");
     const brainAttachmentPolicy = normalizeBrainAttachmentPolicy(input.turn.brainAttachmentPolicy);
+    const profileId = normalizeOptionalString(input.turn.profileId) ?? null;
     if (input.compileResult.ok) {
         const notes = input.compileResult.compileResponse.diagnostics.notes;
         const contextAttribution = buildContextAttributionSummary({
@@ -1345,7 +2802,8 @@ function buildRuntimeTurnAttribution(input) {
         });
         return {
             hostRuntimeOwner: "openclaw",
-            profileSelector: "current_profile",
+            profileSelector,
+            profileId,
             brainAttachmentPolicy,
             brainStatus: "serving_active_pack",
             activePackId: input.compileResult.activePackId,
@@ -1353,6 +2811,17 @@ function buildRuntimeTurnAttribution(input) {
             routerIdentity: input.compileResult.compileResponse.diagnostics.routerIdentity,
             selectionDigest: input.compileResult.compileResponse.diagnostics.selectionDigest,
             selectionTiers: readDiagnosticNoteValue(notes, "selection_tiers="),
+            contextFingerprint: buildRuntimeContextFingerprint({
+                turn: input.turn,
+                sourceStream: input.sourceStream,
+                profileSelector,
+                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
+            }),
             contextEvidence: contextAttribution.evidence === "unprobed" ? null : contextAttribution.evidence
         };
     }
@@ -1363,7 +2832,8 @@ function buildRuntimeTurnAttribution(input) {
     });
     return {
         hostRuntimeOwner: "openclaw",
-        profileSelector: "current_profile",
+        profileSelector,
+        profileId,
         brainAttachmentPolicy,
         brainStatus: input.compileResult.hardRequirementViolated ? "hard_fail" : "fail_open_static_context",
         activePackId: null,
@@ -1371,6 +2841,17 @@ function buildRuntimeTurnAttribution(input) {
         routerIdentity: null,
         selectionDigest: null,
         selectionTiers: null,
+        contextFingerprint: buildRuntimeContextFingerprint({
+            turn: input.turn,
+            sourceStream: input.sourceStream,
+            profileSelector,
+            brainAttachmentPolicy,
+            brainStatus: input.compileResult.hardRequirementViolated ? "hard_fail" : "fail_open_static_context",
+            activePackId: null,
+            usedLearnedRouteFn: null,
+            routerIdentity: null,
+            selectionDigest: null
+        }),
         contextEvidence: contextAttribution.evidence === "unprobed" ? null : contextAttribution.evidence
     };
 }
@@ -1388,10 +2869,6 @@ 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,
@@ -1405,7 +2882,8 @@ function buildCompileInteractionEvent(input) {
             stream: input.sourceStream
         },
         packId: input.compileResult.compileResponse.packId,
-        attribution
+        principal: buildRuntimeSelfPrincipal(input.turn),
+        attribution: input.attribution
     });
 }
 function buildDeliveryInteractionEvent(input) {
@@ -1426,10 +2904,6 @@ 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,
@@ -1442,17 +2916,13 @@ function buildDeliveryInteractionEvent(input) {
             runtimeOwner: "openclaw",
             stream: input.sourceStream
         },
-        attribution,
+        attribution: input.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`);
@@ -1476,6 +2946,12 @@ function buildFeedbackEvents(input) {
             source: input.sourceStream
         });
         const relatedInteractionId = normalizeOptionalString(item.relatedInteractionId) ?? input.compileInteraction?.eventId;
+        const principal = resolveRuntimeFeedbackPrincipal({
+            turn: input.turn,
+            feedback: item,
+            ...(relatedInteractionId === undefined ? {} : { relatedInteractionId }),
+            ...(messageId === undefined ? {} : { messageId })
+        });
         return createFeedbackEvent({
             eventId,
             agentId: input.agentId,
@@ -1489,14 +2965,16 @@ function buildFeedbackEvents(input) {
                 stream: input.sourceStream
             },
             content,
-            attribution,
+            attribution: input.attribution,
             ...(messageId !== undefined ? { messageId } : {}),
+            ...(principal === undefined ? {} : { principal }),
             ...(relatedInteractionId !== undefined ? { relatedInteractionId } : {})
         });
     });
 }
 export function buildNormalizedRuntimeEventExport(turn, compileResult) {
     const agentId = normalizeOptionalString(turn.agentId) ?? process.env.OPENCLAWBRAIN_AGENT_ID ?? DEFAULT_AGENT_ID;
+    const profileSelector = normalizeRuntimeProfileSelector(turn.profileSelector, "profileSelector");
     const sessionId = normalizeNonEmptyString(turn.sessionId, "sessionId");
     const channel = normalizeNonEmptyString(turn.channel, "channel");
     const sourceStream = normalizeOptionalString(turn.sourceStream) ?? `openclaw/runtime/${channel}`;
@@ -1505,12 +2983,19 @@ export function buildNormalizedRuntimeEventExport(turn, compileResult) {
     const normalizedTurn = {
         ...turn,
         agentId,
+        profileSelector,
         channel,
         sessionId
     };
+    const attribution = buildRuntimeTurnAttribution({
+        turn: normalizedTurn,
+        compileResult,
+        sourceStream
+    });
     const compileInteraction = buildCompileInteractionEvent({
         turn: normalizedTurn,
         compileResult,
+        attribution,
         sourceStream,
         nextSequence,
         createdAt: compileCreatedAt,
@@ -1518,6 +3003,7 @@ export function buildNormalizedRuntimeEventExport(turn, compileResult) {
     });
     const feedbackEvents = buildFeedbackEvents({
         turn: normalizedTurn,
+        attribution,
         sourceStream,
         nextSequence,
         defaultCreatedAt: compileCreatedAt,
@@ -1528,6 +3014,7 @@ export function buildNormalizedRuntimeEventExport(turn, compileResult) {
     const deliveryInteraction = buildDeliveryInteractionEvent({
         turn: normalizedTurn,
         compileResult,
+        attribution,
         sourceStream,
         nextSequence,
         defaultCreatedAt: compileCreatedAt,
@@ -1566,21 +3053,33 @@ export function writeRuntimeEventExportBundle(turn, normalizedEventExport) {
         payloadPath: RUNTIME_EVENT_EXPORT_BUNDLE_LAYOUT.payload,
         normalizedEventExport
     });
-    const manifestPath = path.join(resolvedRoot, RUNTIME_EVENT_EXPORT_BUNDLE_LAYOUT.manifest);
-    const payloadPath = path.join(resolvedRoot, manifest.payloadPath);
-    mkdirSync(path.dirname(payloadPath), { recursive: true });
-    writeFileSync(payloadPath, canonicalJson(normalizedEventExport), "utf8");
-    writeFileSync(manifestPath, canonicalJson(manifest), "utf8");
-    const descriptor = loadRuntimeEventExportBundle(resolvedRoot);
-    return {
-        ok: true,
-        wroteBundle: true,
-        normalizedEventExport,
-        rootDir: descriptor.rootDir,
-        manifestPath: descriptor.manifestPath,
-        payloadPath: descriptor.payloadPath,
-        manifest: descriptor.manifest
-    };
+    return writeNormalizedEventExportBundleFiles({
+        rootDir: resolvedRoot,
+        manifest,
+        normalizedEventExport
+    });
+}
+export function writeScannedEventExportBundle(input) {
+    const built = buildNormalizedEventExportFromScannedEvents(input.scannedEventExport);
+    if (!built.ok) {
+        return built;
+    }
+    const rootDir = normalizeNonEmptyString(input.rootDir, "rootDir");
+    const exportName = normalizeOptionalString(input.exportName) ??
+        `${built.scanner.scannerId}-${built.scanner.lane}-${built.normalizedEventExport.range.start}-${built.normalizedEventExport.range.end}`;
+    const exportedAt = normalizeIsoTimestamp(input.exportedAt, "exportedAt", built.scanner.producedAt);
+    const manifest = buildRuntimeEventExportBundleManifest({
+        exportName,
+        exportedAt,
+        payloadPath: RUNTIME_EVENT_EXPORT_BUNDLE_LAYOUT.payload,
+        normalizedEventExport: built.normalizedEventExport,
+        scanner: built.scanner
+    });
+    return writeNormalizedEventExportBundleFiles({
+        rootDir,
+        manifest,
+        normalizedEventExport: built.normalizedEventExport
+    });
 }
 export function runRuntimeTurn(turn, options = {}) {
     const agentId = normalizeOptionalString(turn.agentId);
@@ -1589,6 +3088,7 @@ export function runRuntimeTurn(turn, options = {}) {
         message: normalizeNonEmptyString(turn.userMessage, "userMessage"),
         ...(agentId !== undefined ? { agentId } : {}),
         ...(turn.maxContextBlocks !== undefined ? { maxContextBlocks: turn.maxContextBlocks } : {}),
+        ...(turn.budgetStrategy !== undefined ? { budgetStrategy: turn.budgetStrategy } : {}),
         ...(turn.mode !== undefined ? { mode: turn.mode } : {}),
         ...(turn.runtimeHints !== undefined ? { runtimeHints: turn.runtimeHints } : {})
     };
@@ -1701,6 +3201,7 @@ export function runContinuousProductLoopTurn(input) {
     const mergedHistory = mergeRuntimeEventHistory(currentState, normalizedEventExport);
     currentState.interactionEvents = mergedHistory.interactionEvents;
     currentState.feedbackEvents = mergedHistory.feedbackEvents;
+    const compileStructuralSignals = turnResult.ok ? turnResult.compileResponse.diagnostics.structuralSignals : undefined;
     try {
         let activeBeforePack = null;
         try {
@@ -1719,6 +3220,7 @@ export function runContinuousProductLoopTurn(input) {
             builtAt: normalizeIsoTimestamp(input.candidateBuiltAt, "candidateBuiltAt", normalizedEventExport.range.lastCreatedAt ?? normalizedEventExport.range.firstCreatedAt),
             ...(input.offlineArtifacts !== undefined ? { offlineArtifacts: input.offlineArtifacts } : {}),
             ...(input.structuralOps !== undefined ? { structuralOps: input.structuralOps } : {}),
+            ...(compileStructuralSignals !== undefined ? { compileStructuralSignals } : {}),
             ...(input.sparseFeedback !== undefined ? { sparseFeedback: input.sparseFeedback } : {}),
             ...(input.liveSliceSize !== undefined ? { liveSliceSize: input.liveSliceSize } : {}),
             ...(input.backfillSliceSize !== undefined ? { backfillSliceSize: input.backfillSliceSize } : {}),
@@ -2029,6 +3531,34 @@ function buildReplayTurnScore(input) {
         qualityScore: Math.min(100, compileScore + phraseScore)
     };
 }
+function buildRecordedSessionTurnObservability(result) {
+    if (!result.eventExport.ok) {
+        return {
+            scanPolicy: null,
+            scanSurfaces: [],
+            humanLabelCount: 0,
+            selfLabelCount: 0,
+            totalEventCount: 0,
+            attributedEventCount: 0,
+            selectionDigestCount: 0,
+            freshestSourceStream: null,
+            freshestCreatedAt: null
+        };
+    }
+    const observability = describeNormalizedEventExportObservability(result.eventExport.normalizedEventExport);
+    const freshestSource = observability.supervisionFreshnessBySource[0] ?? null;
+    return {
+        scanPolicy: observability.learningSurface.scanPolicy,
+        scanSurfaces: [...observability.learningSurface.scanSurfaces],
+        humanLabelCount: observability.learningSurface.humanLabelCount,
+        selfLabelCount: observability.learningSurface.selfLabelCount,
+        totalEventCount: observability.attributionCoverage.totalEventCount,
+        attributedEventCount: observability.attributionCoverage.attributedEventCount,
+        selectionDigestCount: observability.attributionCoverage.selectionDigestCount,
+        freshestSourceStream: observability.teacherFreshness.sourceStream ?? freshestSource?.sourceStream ?? null,
+        freshestCreatedAt: observability.teacherFreshness.freshestCreatedAt ?? freshestSource?.freshestCreatedAt ?? null
+    };
+}
 function buildRecordedSessionTurnReport(turnFixture, result, options) {
     const compileOk = result.ok;
     const selectedContextTexts = compileOk ? result.compileResponse.selectedContext.map((block) => block.text) : [];
@@ -2038,6 +3568,7 @@ function buildRecordedSessionTurnReport(turnFixture, result, options) {
         texts: selectedContextTexts,
         expectedContextPhrases: turnFixture.expectedContextPhrases
     });
+    const observability = buildRecordedSessionTurnObservability(result);
     const eventExportDigest = result.eventExport.ok === true ? result.eventExport.normalizedEventExport.provenance.exportDigest : null;
     return {
         turnId: turnFixture.turnId,
@@ -2058,9 +3589,78 @@ function buildRecordedSessionTurnReport(turnFixture, result, options) {
         qualityScore: scoring.qualityScore,
         compileActiveVersion: options.compileActiveVersion,
         promoted: options.promoted,
+        observability,
         warnings: [...result.warnings]
     };
 }
+function countRecordedSessionActivePackChanges(turns) {
+    let changes = 0;
+    let previousPackId = null;
+    for (const turn of turns) {
+        if (turn.activePackId === null) {
+            continue;
+        }
+        if (previousPackId !== null && previousPackId !== turn.activePackId) {
+            changes += 1;
+        }
+        previousPackId = turn.activePackId;
+    }
+    return changes;
+}
+function buildRecordedSessionReplayScannerWarnings(mode, turns, activePackChangeCount) {
+    const warnings = [];
+    const exportTurnCount = turns.filter((turn) => turn.observability.totalEventCount > 0).length;
+    const attributedTurnCount = turns.filter((turn) => turn.observability.attributedEventCount > 0).length;
+    const selectionDigestTurnCount = turns.filter((turn) => turn.observability.selectionDigestCount > 0).length;
+    const humanLabelCount = turns.reduce((sum, turn) => sum + turn.observability.humanLabelCount, 0);
+    const scanSurfaceCount = new Set(turns.flatMap((turn) => turn.observability.scanSurfaces)).size;
+    if (exportTurnCount === 0) {
+        warnings.push("no_export_observability");
+    }
+    if (scanSurfaceCount === 0) {
+        warnings.push("scan_surfaces_missing");
+    }
+    if (humanLabelCount === 0) {
+        warnings.push("human_labels_missing");
+    }
+    if (attributedTurnCount === 0) {
+        warnings.push("turn_attribution_missing");
+    }
+    if (turns.some((turn) => turn.compileOk) && selectionDigestTurnCount === 0) {
+        warnings.push("selection_digest_missing");
+    }
+    if (mode === "learned_replay" && activePackChangeCount === 0) {
+        warnings.push("active_pack_never_moved");
+    }
+    return warnings;
+}
+function buildRecordedSessionReplayScannerEvidence(mode, turns) {
+    const exportTurnCount = turns.filter((turn) => turn.observability.totalEventCount > 0).length;
+    const scanSurfaces = uniqueStringsInOrder(turns.flatMap((turn) => turn.observability.scanSurfaces));
+    const attributedTurnCount = turns.filter((turn) => turn.observability.attributedEventCount > 0).length;
+    const selectionDigestTurnCount = turns.filter((turn) => turn.observability.selectionDigestCount > 0).length;
+    const activePackChangeCount = countRecordedSessionActivePackChanges(turns);
+    const latestObservedTurn = [...turns]
+        .filter((turn) => turn.observability.freshestCreatedAt !== null)
+        .sort((left, right) => (right.observability.freshestCreatedAt ?? "").localeCompare(left.observability.freshestCreatedAt ?? ""))[0];
+    return {
+        exportTurnCount,
+        scanPolicy: turns.find((turn) => turn.observability.scanPolicy !== null)?.observability.scanPolicy ?? null,
+        scanSurfaceCount: scanSurfaces.length,
+        scanSurfaces,
+        humanLabelCount: turns.reduce((sum, turn) => sum + turn.observability.humanLabelCount, 0),
+        selfLabelCount: turns.reduce((sum, turn) => sum + turn.observability.selfLabelCount, 0),
+        totalEventCount: turns.reduce((sum, turn) => sum + turn.observability.totalEventCount, 0),
+        attributedEventCount: turns.reduce((sum, turn) => sum + turn.observability.attributedEventCount, 0),
+        attributedTurnCount,
+        selectionDigestCount: turns.reduce((sum, turn) => sum + turn.observability.selectionDigestCount, 0),
+        selectionDigestTurnCount,
+        activePackChangeCount,
+        freshestSourceStream: latestObservedTurn?.observability.freshestSourceStream ?? null,
+        freshestCreatedAt: latestObservedTurn?.observability.freshestCreatedAt ?? null,
+        warnings: buildRecordedSessionReplayScannerWarnings(mode, turns, activePackChangeCount)
+    };
+}
 function buildRecordedSessionReplayModeSummary(mode, turns) {
     const compileOkCount = turns.filter((turn) => turn.compileOk).length;
     const phraseHitCount = turns.reduce((sum, turn) => sum + turn.phraseHits.length, 0);
@@ -2069,6 +3669,7 @@ function buildRecordedSessionReplayModeSummary(mode, turns) {
     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 scannerEvidence = buildRecordedSessionReplayScannerEvidence(mode, turns);
     const base = {
         mode,
         qualityScore,
@@ -2077,7 +3678,8 @@ function buildRecordedSessionReplayModeSummary(mode, turns) {
         phraseCount,
         usedLearnedRouteTurnCount,
         promotionCount,
-        packIds
+        packIds,
+        scannerEvidence
     };
     return {
         ...base,
@@ -2115,6 +3717,7 @@ function buildRecordedSessionReplayScoreHash(modes) {
         usedLearnedRouteTurnCount: mode.summary.usedLearnedRouteTurnCount,
         promotionCount: mode.summary.promotionCount,
         packIds: mode.summary.packIds,
+        scannerEvidence: mode.summary.scannerEvidence,
         scoreHash: mode.summary.scoreHash
     })));
 }
@@ -2145,6 +3748,17 @@ function recordedSessionReplayBundleBase(bundle) {
                 expectedContextPhrases: [...turn.expectedContextPhrases],
                 phraseHits: [...turn.phraseHits],
                 missedPhrases: [...turn.missedPhrases],
+                observability: {
+                    scanPolicy: turn.observability.scanPolicy,
+                    scanSurfaces: [...turn.observability.scanSurfaces],
+                    humanLabelCount: turn.observability.humanLabelCount,
+                    selfLabelCount: turn.observability.selfLabelCount,
+                    totalEventCount: turn.observability.totalEventCount,
+                    attributedEventCount: turn.observability.attributedEventCount,
+                    selectionDigestCount: turn.observability.selectionDigestCount,
+                    freshestSourceStream: turn.observability.freshestSourceStream,
+                    freshestCreatedAt: turn.observability.freshestCreatedAt
+                },
                 warnings: [...turn.warnings]
             }))
         })),
@@ -2536,6 +4150,39 @@ function summarizeCandidateAheadBy(candidateAheadBy) {
         .map(([field]) => field)
         .sort();
 }
+function summarizeManyProfileSupport(policyMode) {
+    if (policyMode === "shared") {
+        return {
+            operatorSurface: "current_profile_only",
+            declaredAttachmentPolicy: "shared",
+            sameGatewayIntent: "shared_attachment_declared",
+            checkedInProofTopology: "two_local_gateways_dedicated_only",
+            sameGatewayProof: false,
+            sharedWriteSafetyProof: false,
+            detail: "The Host declares that multiple Profiles may intentionally attach to this Brain activation root, but the shipped operator read stays current-profile-only and this repo still does not prove same-gateway attachment behavior or shared write safety."
+        };
+    }
+    if (policyMode === "dedicated") {
+        return {
+            operatorSurface: "current_profile_only",
+            declaredAttachmentPolicy: "dedicated",
+            sameGatewayIntent: "dedicated_current_profile_boundary",
+            checkedInProofTopology: "two_local_gateways_dedicated_only",
+            sameGatewayProof: false,
+            sharedWriteSafetyProof: false,
+            detail: "The Host declares one current Profile per Brain activation root. The checked-in many-profile proof is still narrower: two local gateways with dedicated brains, not same-gateway many-profile attachment inside one running host."
+        };
+    }
+    return {
+        operatorSurface: "current_profile_only",
+        declaredAttachmentPolicy: "undeclared",
+        sameGatewayIntent: "undeclared",
+        checkedInProofTopology: "two_local_gateways_dedicated_only",
+        sameGatewayProof: false,
+        sharedWriteSafetyProof: false,
+        detail: "The Host has not declared shared-vs-dedicated attachment policy. Keep the operator read current-profile-only, do not infer profile exclusivity from activation state alone, and do not claim same-gateway many-profile proof."
+    };
+}
 function isAwaitingFirstExportSlot(slot) {
     return slot !== null && slot.eventRange.count === 0;
 }
@@ -2571,7 +4218,56 @@ function summarizeBrainState(active, observability) {
         detail
     };
 }
+function summarizeGraphObservability(active, observability) {
+    if (active === null) {
+        return {
+            available: false,
+            runtimePlasticitySource: null,
+            structuralOps: null,
+            changed: null,
+            operationsApplied: [],
+            liveBlockCount: null,
+            prunedBlockCount: null,
+            prePruneBlockCount: null,
+            strongestBlockId: null,
+            operatorSummary: null,
+            detail: "no active pack is pinned, so there is no structural graph surface to inspect"
+        };
+    }
+    const graphEvolution = observability.graphEvolutionLog;
+    if (graphEvolution === null) {
+        return {
+            available: false,
+            runtimePlasticitySource: observability.graphDynamics.runtimePlasticitySource,
+            structuralOps: null,
+            changed: null,
+            operationsApplied: [],
+            liveBlockCount: null,
+            prunedBlockCount: null,
+            prePruneBlockCount: null,
+            strongestBlockId: null,
+            operatorSummary: null,
+            detail: "active pack is present, but the graph evolution log is missing from activation observability"
+        };
+    }
+    return {
+        available: true,
+        runtimePlasticitySource: observability.graphDynamics.runtimePlasticitySource,
+        structuralOps: { ...graphEvolution.structuralOps },
+        changed: graphEvolution.structuralEvolutionSummary.changed,
+        operationsApplied: [...graphEvolution.structuralEvolutionSummary.operationsApplied],
+        liveBlockCount: graphEvolution.structuralEvolutionSummary.liveBlockCount,
+        prunedBlockCount: graphEvolution.structuralEvolutionSummary.prunedBlockCount,
+        prePruneBlockCount: graphEvolution.structuralEvolutionSummary.prePruneBlockCount,
+        strongestBlockId: graphEvolution.strongestBlockId,
+        operatorSummary: graphEvolution.structuralEvolutionSummary.operatorSummary,
+        detail: graphEvolution.structuralEvolutionSummary.changed
+            ? graphEvolution.structuralEvolutionSummary.operatorSummary
+            : "active pack graph is stable with no structural evolution beyond the current promoted artifact"
+    };
+}
 function summarizeServePath(compile) {
+    const structuralDecision = summarizeStructuralDecisionFromNotes(compile?.notes ?? []);
     if (compile === null) {
         return {
             state: "unprobed",
@@ -2583,6 +4279,13 @@ function summarizeServePath(compile) {
             selectionMode: null,
             refreshStatus: null,
             freshnessChecksum: null,
+            requestedBudgetStrategy: null,
+            resolvedBudgetStrategy: null,
+            resolvedMaxContextBlocks: null,
+            structuralBudgetSource: null,
+            structuralBudgetEvidence: null,
+            structuralBudgetPressures: null,
+            structuralDecision,
             contextAttribution: buildContextAttributionSummary({
                 fallbackToStaticContext: false,
                 hardRequirementViolated: false,
@@ -2603,6 +4306,13 @@ function summarizeServePath(compile) {
             selectionMode: null,
             refreshStatus: null,
             freshnessChecksum: null,
+            requestedBudgetStrategy: null,
+            resolvedBudgetStrategy: null,
+            resolvedMaxContextBlocks: null,
+            structuralBudgetSource: null,
+            structuralBudgetEvidence: null,
+            structuralBudgetPressures: null,
+            structuralDecision,
             contextAttribution: compile.contextAttribution,
             error: compile.error
         };
@@ -2617,6 +4327,14 @@ function summarizeServePath(compile) {
         selectionMode: readDiagnosticNoteValue(compile.notes, "selection_mode="),
         refreshStatus: readDiagnosticNoteValue(compile.notes, "router_refresh_status="),
         freshnessChecksum: readDiagnosticNoteValue(compile.notes, "router_freshness_checksum="),
+        requestedBudgetStrategy: readDiagnosticNoteValue(compile.notes, "requested_budget_strategy="),
+        resolvedBudgetStrategy: readDiagnosticNoteValue(compile.notes, "resolved_budget_strategy="),
+        resolvedMaxContextBlocks: structuralDecision.resolvedMaxContextBlocks,
+        structuralBudgetSource: readDiagnosticNoteValue(compile.notes, "structural_budget_source="),
+        structuralBudgetEvidence: readDiagnosticNoteValue(compile.notes, "structural_budget_compile_evidence=") ??
+            readDiagnosticNoteValue(compile.notes, "structural_budget_evidence="),
+        structuralBudgetPressures: readDiagnosticNoteValue(compile.notes, "structural_budget_pressures="),
+        structuralDecision,
         contextAttribution: compile.contextAttribution,
         error: compile.error
     };
@@ -2765,11 +4483,18 @@ function summarizeSupervision(input) {
             exportDigest: null,
             exportedAt: null,
             flowing: null,
+            scanPolicy: null,
+            scanSurfaceCount: 0,
+            scanSurfaces: [],
             sourceCount: 0,
             freshestSourceStream: null,
             freshestCreatedAt: null,
             freshestKind: null,
             humanLabelCount: null,
+            selfLabelCount: null,
+            attributedEventCount: null,
+            totalEventCount: null,
+            selectionDigestCount: null,
             sources: [],
             detail: "no event export path supplied"
         };
@@ -2784,11 +4509,18 @@ function summarizeSupervision(input) {
         exportDigest: observability.exportDigest,
         exportedAt: loaded.exportedAt,
         flowing,
+        scanPolicy: observability.learningSurface.scanPolicy,
+        scanSurfaceCount: observability.learningSurface.scanSurfaces.length,
+        scanSurfaces: [...observability.learningSurface.scanSurfaces],
         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,
+        selfLabelCount: observability.learningSurface.selfLabelCount,
+        attributedEventCount: observability.attributionCoverage.attributedEventCount,
+        totalEventCount: observability.attributionCoverage.totalEventCount,
+        selectionDigestCount: observability.attributionCoverage.selectionDigestCount,
         sources: [...observability.teacherFreshness.sources],
         detail: flowing
             ? "human supervision is visible in the supplied export"
@@ -2853,6 +4585,53 @@ function summarizeTeacherLoop(input) {
         detail: "async teacher diagnostics loaded"
     };
 }
+function summarizeLearningBacklogState(plan, principalLagStatus) {
+    if (!plan.bootstrapped && plan.pending.total === 0) {
+        return "awaiting_first_export";
+    }
+    if (plan.nextPriorityBucket === "principal_immediate") {
+        return "principal_live_priority";
+    }
+    if (plan.nextPriorityBucket === "principal_backfill") {
+        return "principal_backfill_priority";
+    }
+    if (plan.nextPriorityBucket === "live") {
+        return "live_priority";
+    }
+    if (plan.nextPriorityBucket === "backfill") {
+        return "backfill_only";
+    }
+    return principalLagStatus === "pending_promotion" ? "principal_live_priority" : "caught_up";
+}
+function summarizeLearningWarningStates(input) {
+    const warnings = new Set();
+    if (!input.plan.bootstrapped && input.plan.pending.total === 0) {
+        warnings.add("awaiting_first_export");
+    }
+    if (input.plan.pending.byBucket.principal_immediate > 0) {
+        warnings.add("principal_live_backlog");
+    }
+    if (input.plan.pending.byBucket.principal_backfill > 0) {
+        warnings.add("principal_backfill_pending");
+    }
+    if (input.principalLagStatus === "pending_promotion") {
+        warnings.add("active_pack_behind_latest_principal");
+    }
+    if (input.plan.pending.backfill > 0) {
+        warnings.add("passive_backfill_pending");
+    }
+    if (input.teacherSnapshot.queue.capacity > 0 &&
+        input.teacherSnapshot.queue.depth >= input.teacherSnapshot.queue.capacity) {
+        warnings.add("teacher_queue_full");
+    }
+    if (input.teacherSnapshot.diagnostics.latestFreshness === "stale") {
+        warnings.add("teacher_labels_stale");
+    }
+    if (input.teacherSnapshot.diagnostics.lastNoOpReason === "no_teacher_artifacts") {
+        warnings.add("teacher_no_artifacts");
+    }
+    return [...warnings];
+}
 function summarizeAlwaysOnLearning(input, active) {
     const unavailableLag = {
         activeEventRangeEnd: active?.eventRange.end ?? null,
@@ -2868,15 +4647,21 @@ function summarizeAlwaysOnLearning(input, active) {
             bootstrapped: null,
             mode: "unavailable",
             nextPriorityLane: "unavailable",
+            nextPriorityBucket: "unavailable",
+            backlogState: "unavailable",
             pendingLive: null,
             pendingBackfill: null,
             pendingTotal: null,
+            pendingByBucket: null,
             freshLivePriority: null,
             principalCheckpointCount: null,
             pendingPrincipalCount: null,
             oldestUnlearnedPrincipalEvent: null,
+            newestPendingPrincipalEvent: null,
+            leadingPrincipalCheckpoint: null,
             principalCheckpoints: [],
             principalLagToPromotion: unavailableLag,
+            warningStates: ["teacher_snapshot_unavailable"],
             learnedRange: null,
             materializationCount: null,
             lastMaterializedAt: null,
@@ -2895,15 +4680,21 @@ function summarizeAlwaysOnLearning(input, active) {
             bootstrapped: null,
             mode: "unavailable",
             nextPriorityLane: "unavailable",
+            nextPriorityBucket: "unavailable",
+            backlogState: "unavailable",
             pendingLive: null,
             pendingBackfill: null,
             pendingTotal: null,
+            pendingByBucket: null,
             freshLivePriority: null,
             principalCheckpointCount: null,
             pendingPrincipalCount: null,
             oldestUnlearnedPrincipalEvent: null,
+            newestPendingPrincipalEvent: null,
+            leadingPrincipalCheckpoint: null,
             principalCheckpoints: [],
             principalLagToPromotion: unavailableLag,
+            warningStates: ["teacher_snapshot_unavailable"],
             learnedRange: null,
             materializationCount: null,
             lastMaterializedAt: null,
@@ -2926,30 +4717,43 @@ function summarizeAlwaysOnLearning(input, active) {
     const sequenceLag = latestPrincipalSequence === null || activeEventRangeEnd === null
         ? null
         : Math.max(latestPrincipalSequence - activeEventRangeEnd, 0);
+    const principalLagStatus = sequenceLag === null
+        ? "unavailable"
+        : sequenceLag === 0
+            ? "caught_up"
+            : "pending_promotion";
+    const backlogState = summarizeLearningBacklogState(plan, principalLagStatus);
+    const warningStates = summarizeLearningWarningStates({
+        plan,
+        principalLagStatus,
+        teacherSnapshot: snapshot
+    });
     return {
         available: true,
         sourcePath: path.resolve(teacherSnapshotPath),
         bootstrapped: plan.bootstrapped,
         mode: plan.mode,
         nextPriorityLane: plan.nextPriorityLane,
+        nextPriorityBucket: plan.nextPriorityBucket,
+        backlogState,
         pendingLive: plan.pending.live,
         pendingBackfill: plan.pending.backfill,
         pendingTotal: plan.pending.total,
+        pendingByBucket: { ...plan.pending.byBucket },
         freshLivePriority: plan.pending.freshLivePriority,
         principalCheckpointCount: plan.principalBacklog.principalCount,
         pendingPrincipalCount: plan.principalBacklog.pendingEventCount,
         oldestUnlearnedPrincipalEvent: plan.principalBacklog.oldestUnlearnedEvent,
+        newestPendingPrincipalEvent: plan.principalBacklog.newestPendingEvent,
+        leadingPrincipalCheckpoint: plan.principalBacklog.checkpoints[0] ?? null,
         principalCheckpoints: plan.principalBacklog.checkpoints,
         principalLagToPromotion: {
             activeEventRangeEnd,
             latestPrincipalSequence,
             sequenceLag,
-            status: sequenceLag === null
-                ? "unavailable"
-                : sequenceLag === 0
-                    ? "caught_up"
-                    : "pending_promotion"
+            status: principalLagStatus
         },
+        warningStates,
         learnedRange: plan.learnedRange === null ? null : { ...plan.learnedRange },
         materializationCount: plan.materialization.count,
         lastMaterializedAt: plan.materialization.lastMaterializedAt,
@@ -2957,13 +4761,17 @@ function summarizeAlwaysOnLearning(input, active) {
         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"
+        detail: plan.nextPriorityBucket === "principal_immediate"
+            ? "principal-priority live slices are next; passive backfill stays behind live intake"
+            : plan.nextPriorityBucket === "live"
+                ? "fresh live slices are next; passive backfill stays behind live intake"
+                : plan.nextPriorityBucket === "principal_backfill"
+                    ? "live intake is clear; principal-priority passive backfill is next"
+                    : plan.nextPriorityBucket === "backfill"
+                        ? "live intake is clear; passive backfill is next"
+                        : 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) {
@@ -2996,6 +4804,7 @@ function buildOperatorFindings(report) {
     }
     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"}`);
+        push("pass", "structural_budget_visible", `structural budget resolves to ${report.servePath.resolvedMaxContextBlocks ?? "unknown"} blocks`, `origin=${report.servePath.structuralDecision.origin}; basis=${report.servePath.structuralDecision.basis}; requested=${report.servePath.requestedBudgetStrategy ?? "unknown"}; resolved=${report.servePath.resolvedBudgetStrategy ?? "unknown"}; source=${report.servePath.structuralBudgetSource ?? "unknown"}; evidence=${report.servePath.structuralBudgetEvidence ?? "none"}; pressures=${report.servePath.structuralBudgetPressures ?? "none"}`);
     }
     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");
@@ -3052,6 +4861,22 @@ function buildOperatorFindings(report) {
     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.supervision.available) {
+        if (report.supervision.scanSurfaceCount > 0) {
+            push("pass", "scan_surfaces_visible", `scanner surfaces are visible: ${formatList(report.supervision.scanSurfaces)}`, `scanPolicy=${report.supervision.scanPolicy ?? "unknown"}; humanLabels=${report.supervision.humanLabelCount ?? 0}; selfLabels=${report.supervision.selfLabelCount ?? 0}`);
+        }
+        else {
+            push("warn", "scan_surfaces_missing", "scanner surfaces are not visible in the supplied export", `exportDigest=${report.supervision.exportDigest ?? "unknown"}`);
+        }
+        if (report.supervision.totalEventCount !== null && report.supervision.totalEventCount > 0) {
+            if (report.supervision.attributedEventCount === report.supervision.totalEventCount) {
+                push("pass", "turn_attribution_visible", `all supplied events are attributable: ${report.supervision.attributedEventCount}/${report.supervision.totalEventCount}`, `selectionDigests=${report.supervision.selectionDigestCount ?? 0}`);
+            }
+            else {
+                push("warn", "turn_attribution_partial", `some supplied events are unattributed: ${report.supervision.attributedEventCount ?? 0}/${report.supervision.totalEventCount}`, `selectionDigests=${report.supervision.selectionDigestCount ?? 0}`);
+            }
+        }
+    }
     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");
     }
@@ -3133,7 +4958,7 @@ function summarizeCurrentProfileBrainStatusLevel(input) {
     }
     return input.routeFreshness === "updated" ? "ok" : "warn";
 }
-function buildCurrentProfileBrainStatusFromReport(report, policyMode) {
+function buildCurrentProfileBrainStatusFromReport(report, policyMode, profileId) {
     const attached = report.active !== null;
     const awaitingFirstExport = isAwaitingFirstExportSlot(report.active);
     const routerIdentity = report.servePath.routerIdentity ?? report.learnedRouting.routerIdentity ?? report.active?.routerIdentity ?? null;
@@ -3158,6 +4983,7 @@ function buildCurrentProfileBrainStatusFromReport(report, policyMode) {
         profile: {
             noun: "Profile",
             selector: "current_profile",
+            profileId,
             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."
@@ -3214,6 +5040,7 @@ function buildCurrentProfileBrainStatusFromReport(report, policyMode) {
             usedLearnedRouteFn: report.servePath.usedLearnedRouteFn,
             failOpen: report.servePath.fallbackToStaticContext,
             awaitingFirstExport,
+            structuralDecision: report.servePath.structuralDecision,
             detail: report.servePath.state === "serving_active_pack"
                 ? awaitingFirstExport
                     ? `current profile is serving seed-state pack ${activePackId ?? "unknown"} while awaiting the first exported turn`
@@ -3232,6 +5059,7 @@ function buildCurrentProfileBrainStatusFromReport(report, policyMode) {
 export function buildOperatorSurfaceReport(input) {
     const activationRoot = path.resolve(normalizeNonEmptyString(input.activationRoot, "activationRoot"));
     const updatedAt = normalizeIsoTimestamp(input.updatedAt, "updatedAt", new Date().toISOString());
+    const brainAttachmentPolicy = normalizeBrainAttachmentPolicy(input.brainAttachmentPolicy);
     const inspection = inspectActivationState(activationRoot, updatedAt);
     const observability = describeActivationObservability(activationRoot, "active", {
         updatedAt
@@ -3249,6 +5077,7 @@ export function buildOperatorSurfaceReport(input) {
             candidateAheadBy: summarizeCandidateAheadBy(observability.promotionFreshness.candidateAheadBy)
         },
         brain: summarizeBrainState(active, observability),
+        graph: summarizeGraphObservability(active, observability),
         learnedRouting: {
             required: observability.learnedRouteFn.required,
             available: observability.learnedRouteFn.available,
@@ -3288,7 +5117,8 @@ export function buildOperatorSurfaceReport(input) {
         supervision: summarizeSupervision(input),
         learning: summarizeAlwaysOnLearning(input, active),
         teacherLoop: summarizeTeacherLoop(input),
-        principal: summarizePrincipalObservability(input, active)
+        principal: summarizePrincipalObservability(input, active),
+        manyProfile: summarizeManyProfileSupport(brainAttachmentPolicy)
     };
     const findings = buildOperatorFindings(reportBase);
     return {
@@ -3299,7 +5129,7 @@ export function buildOperatorSurfaceReport(input) {
 }
 export function describeCurrentProfileBrainStatus(input) {
     const report = buildOperatorSurfaceReport(input);
-    return buildCurrentProfileBrainStatusFromReport(report, normalizeBrainAttachmentPolicy(input.brainAttachmentPolicy));
+    return buildCurrentProfileBrainStatusFromReport(report, report.manyProfile.declaredAttachmentPolicy, normalizeOptionalString(input.profileId) ?? null);
 }
 export function formatOperatorRollbackReport(result) {
     const header = result.allowed ? (result.dryRun ? "ROLLBACK ready" : "ROLLBACK ok") : "ROLLBACK blocked";
@@ -3367,4 +5197,7 @@ export { CONTRACT_IDS, buildNormalizedEventExport, createFeedbackEvent, createIn
 export { describeNormalizedEventExportObservability } from "@openclawbrain/event-export";
 export { describeCompileFallbackUsage } from "@openclawbrain/compiler";
 export { describeActivationObservability, inspectActivationState, rollbackActivePack } from "@openclawbrain/pack-format";
+export { createOpenClawLocalSessionTail, OpenClawLocalSessionTail } from "./session-tail.js";
+export { discoverOpenClawMainSessionStores, loadOpenClawSessionIndex, readOpenClawAcpStreamFile, readOpenClawSessionFile } from "./session-store.js";
+export { buildPassiveLearningSessionExportFromOpenClawSessionStore, buildPassiveLearningStoreExportFromOpenClawSessionIndex } from "./local-session-passive-learning.js";
 //# sourceMappingURL=index.js.map