@openclawbrain/cli 0.4.25 → 0.4.27

package/dist/src/cli.js

@@ -13,11 +13,11 @@ import { buildTeacherSupervisionArtifactsFromNormalizedEventExport, createAlways
 import { inspectActivationState, loadPackFromActivation, promoteCandidatePack, resolveLearningSpineLogPath, stageCandidatePack } from "@openclawbrain/pack-format";
 import { resolveActivationRoot } from "./resolve-activation-root.js";
 import { describeOpenClawHomeInspection, discoverOpenClawHomes, formatOpenClawHomeLayout, formatOpenClawHomeProfileSource, inspectOpenClawHome } from "./openclaw-home-layout.js";
-import { inspectOpenClawBrainHookStatus, inspectOpenClawBrainPluginAllowlist } from "./openclaw-hook-truth.js";
+import { describeOpenClawBrainHotfixBoundary, inspectOpenClawBrainHookStatus, inspectOpenClawBrainPluginAllowlist } from "./openclaw-hook-truth.js";
 import { describeOpenClawBrainInstallIdentity, describeOpenClawBrainInstallLayout, findInstalledOpenClawBrainPlugin, getOpenClawBrainKnownPluginIds, normalizeOpenClawBrainPluginsConfig, pinInstalledOpenClawBrainPluginActivationRoot, resolveOpenClawBrainInstallTarget } from "./openclaw-plugin-install.js";
 import { buildOpenClawBrainConvergeRestartPlan, classifyOpenClawBrainConvergeVerification, describeOpenClawBrainConvergeChangeReasons, diffOpenClawBrainConvergeRuntimeFingerprint, finalizeOpenClawBrainConvergeResult, planOpenClawBrainConvergePluginAction, shouldReplaceOpenClawBrainInstallBeforeConverge } from "./install-converge.js";
 import { loadAttachmentPolicyDeclaration, resolveEffectiveAttachmentPolicyTruth, writeAttachmentPolicyDeclaration } from "./attachment-policy-truth.js";
-import { DEFAULT_WATCH_POLL_INTERVAL_SECONDS, buildNormalizedEventExportFromScannedEvents, bootstrapRuntimeAttach, buildOperatorSurfaceReport, clearOpenClawProfileRuntimeLoadProof, compileRuntimeContext, createAsyncTeacherLiveLoop, createOpenClawLocalSessionTail, createRuntimeEventExportScanner, describeCurrentProfileBrainStatus, formatOperatorRollbackReport, listOpenClawProfileRuntimeLoadProofs, loadRuntimeEventExportBundle, loadWatchTeacherSnapshotState, persistWatchTeacherSnapshot, rollbackRuntimeAttach, resolveAttachmentRuntimeLoadProofsPath, resolveOperatorTeacherSnapshotPath, resolveAsyncTeacherLiveLoopSnapshotPath, resolveWatchSessionTailCursorPath, resolveWatchStateRoot, resolveWatchTeacherSnapshotPath, scanLiveEventExport, scanRecordedSession, summarizeLearningPathFromMaterialization, summarizeNormalizedEventExportLabelFlow, summarizeTeacherNoArtifactCycle, writeScannedEventExportBundle } from "./index.js";
+import { DEFAULT_WATCH_POLL_INTERVAL_SECONDS, buildNormalizedEventExportFromScannedEvents, bootstrapRuntimeAttach, clearOpenClawProfileRuntimeLoadProof, compileRuntimeContext, createAsyncTeacherLiveLoop, createOpenClawLocalSessionTail, createRuntimeEventExportScanner, describeCurrentProfileBrainStatusWithReport, formatOperatorRollbackReport, listOpenClawProfileRuntimeLoadProofs, loadRuntimeEventExportBundle, loadWatchTeacherSnapshotState, persistWatchTeacherSnapshot, rollbackRuntimeAttach, resolveAttachmentRuntimeLoadProofsPath, resolveOperatorTeacherSnapshotPath, resolveAsyncTeacherLiveLoopSnapshotPath, resolveWatchSessionTailCursorPath, resolveWatchStateRoot, resolveWatchTeacherSnapshotPath, scanLiveEventExport, scanRecordedSession, summarizeLearningPathFromMaterialization, summarizeNormalizedEventExportLabelFlow, summarizeTeacherNoArtifactCycle, writeScannedEventExportBundle } from "./index.js";
 import { appendLearningUpdateLogs } from "./learning-spine.js";
 import { buildPassiveLearningSessionExportFromOpenClawSessionStore } from "./local-session-passive-learning.js";
 import { reindexMaterializationCandidateWithEmbedder } from "./materialization-embedder.js";
@@ -25,7 +25,7 @@ import { summarizePackVectorEmbeddingState } from "./embedding-status.js";
 import { buildTracedLearningBridgePayloadFromRuntime, buildTracedLearningStatusSurface, persistTracedLearningBridgeState } from "./traced-learning-bridge.js";
 import { discoverOpenClawSessionStores, loadOpenClawSessionIndex, readOpenClawSessionFile } from "./session-store.js";
 import { readOpenClawBrainProviderDefaults, readOpenClawBrainProviderConfig, readOpenClawBrainProviderConfigFromSources, resolveOpenClawBrainProviderDefaultsPath } from "./provider-config.js";
-import { formatOperatorAttributionCoverageSummary, formatOperatorFeedbackSummary, formatOperatorLearningAttributionSummary, formatOperatorLearningPathSummary } from "./status-learning-path.js";
+import { formatOperatorAttributionCoverageSummary, formatOperatorFeedbackSummary, formatOperatorLearningAttributionSummary, formatOperatorLearningFlowSummary, formatOperatorLearningHealthSummary, formatOperatorLearningPathSummary } from "./status-learning-path.js";
 import { buildProofCommandForOpenClawHome, buildProofCommandHelpSection, captureOperatorProofBundle, formatOperatorProofResult, parseProofCliArgs } from "./proof-command.js";
 const OPENCLAWBRAIN_EMBEDDER_BASE_URL_ENV = "OPENCLAWBRAIN_EMBEDDER_BASE_URL";
 const OPENCLAWBRAIN_EMBEDDER_PROVIDER_ENV = "OPENCLAWBRAIN_EMBEDDER_PROVIDER";
@@ -950,6 +950,27 @@ function summarizeStatusAttachmentTruth(input) {
         })
     };
 }
+function summarizeStatusHotfixBoundary(status) {
+    return describeOpenClawBrainHotfixBoundary({
+        hookInspection: status.hook,
+        daemonInspection: inspectManagedLearnerService(status.host.activationRoot)
+    });
+}
+function formatStatusHotfixBoundarySummary(boundary) {
+    return [
+        `boundary=${boundary.boundary}`,
+        `skew=${boundary.skew}`,
+        `daemon=${boundary.daemonPackage ?? "unverified"}`,
+        `hook=${boundary.hookPackage ?? "unverified"}`
+    ].join(" ");
+}
+function formatStatusHotfixBoundaryPaths(boundary) {
+    return [
+        `daemonPath=${boundary.daemonPath === null ? "none" : shortenPath(boundary.daemonPath)}`,
+        `hookPath=${boundary.hookPath === null ? "unverified" : shortenPath(boundary.hookPath)}`,
+        `runtimeGuard=${boundary.runtimeGuardPath === null ? "unverified" : shortenPath(boundary.runtimeGuardPath)}`
+    ].join(" ");
+}
 function normalizeAttachmentPolicyMode(value) {
     return value === "undeclared" || value === "dedicated" || value === "shared"
         ? value
@@ -1417,6 +1438,7 @@ function formatTracedLearningSurface(surface) {
 function buildCompactStatusHeader(status, report, options) {
     const installHook = summarizeStatusInstallHook(options.openclawHome);
     const hookLoad = summarizeStatusHookLoad(installHook, status);
+    const hotfixBoundary = summarizeStatusHotfixBoundary(status);
     const embeddings = summarizeStatusEmbeddings(report, options.providerConfig);
     const localLlm = summarizeStatusLocalLlm(options.providerConfig);
     const teacher = summarizeStatusTeacher(report, options.providerConfig, localLlm);
@@ -1433,6 +1455,9 @@ function buildCompactStatusHeader(status, report, options) {
     return [
         `lifecycle   attach=${status.attachment.state} learner=${yesNo(status.passiveLearning.learnerRunning)} watch=${summarizeStatusWatchState(status)} export=${status.passiveLearning.exportState} promote=${summarizeStatusPromotionState(status)} serve=${summarizeStatusServeReality(status)}`,
         `hook        install=${hookLoad.installState} loadability=${hookLoad.loadability} loadProof=${hookLoad.loadProof} layout=${status.hook.installLayout ?? "unverified"} additional=${status.hook.additionalInstallCount ?? 0} severity=${hookLoad.guardSeverity} actionability=${hookLoad.guardActionability} summary=${hookLoad.guardSummary}`,
+        `surface     ${formatStatusHotfixBoundarySummary(hotfixBoundary)}`,
+        `surfaces    ${formatStatusHotfixBoundaryPaths(hotfixBoundary)}`,
+        `hotfix      ${hotfixBoundary.guidance}`,
         `attachTruth current=${attachmentTruth.currentProfileLabel} hook=${attachmentTruth.hookFiles} config=${attachmentTruth.configLoad} runtime=${attachmentTruth.runtimeLoad} watcher=${attachmentTruth.watcher} attachedSet=${formatAttachedProfileTruthCompactList(attachmentTruth.attachedProfiles)} why=${attachmentTruth.detail}`,
         `passive     firstExport=${yesNo(status.passiveLearning.firstExportOccurred)} backlog=${status.passiveLearning.backlogState} pending=${formatStatusNullableNumber(status.passiveLearning.pendingLive)}/${formatStatusNullableNumber(status.passiveLearning.pendingBackfill)}`,
         `serving     pack=${status.passiveLearning.currentServingPackId ?? "none"} lastExport=${status.passiveLearning.lastExportAt ?? "none"} lastPromotion=${status.passiveLearning.lastPromotionAt ?? "none"}`,
@@ -1442,6 +1467,8 @@ function buildCompactStatusHeader(status, report, options) {
         `explain     ${status.brain.summary}`,
         `graph       blocks=${report.graph.blockCount ?? "none"} strongest=${report.graph.strongestBlockId ?? "none"} latest=${report.graph.latestMaterialization.packId ?? "none"} latestChanged=${yesNo(report.graph.latestMaterialization.changed)} connect=${formatCompactGraphConnectDiagnostics(report.graph.latestMaterialization.connectDiagnostics ?? report.graph.connectDiagnostics)}`,
         `attribution ${formatOperatorLearningAttributionSummary({ status })}`,
+        `learnFlow   ${formatOperatorLearningFlowSummary({ tracedLearning })}`,
+        `health      ${formatOperatorLearningHealthSummary({ tracedLearning, teacher })}`,
         `teacher     model=${teacher.model} enabled=${yesNo(teacher.enabled)} healthy=${yesNo(teacher.healthy)} stale=${yesNo(teacher.stale)} idle=${yesNo(teacher.idle)} cycle=${teacher.latestCycle} why=${teacher.detail}`,
         `embedder    model=${embedder.model} provisioned=${yesNo(embedder.provisioned)} live=${yesNo(embedder.live)} why=${embedder.detail}`,
         `routeFn     available=${yesNo(routeFn.available)} freshness=${routeFn.freshness} trained=${routeFn.trainedAt ?? "none"} updated=${routeFn.updatedAt ?? "none"} used=${routeFn.usedAt ?? "none"} why=${routeFn.detail}`,
@@ -1454,8 +1481,10 @@ function buildCompactStatusHeader(status, report, options) {
 function formatCurrentProfileStatusSummary(status, report, targetInspection, options) {
     const installHook = summarizeStatusInstallHook(options.openclawHome);
     const displayedStatus = summarizeDisplayedStatus(status, installHook);
+    const hotfixBoundary = summarizeStatusHotfixBoundary(status);
     const embeddings = summarizeStatusEmbeddings(report, options.providerConfig);
     const localLlm = summarizeStatusLocalLlm(options.providerConfig);
+    const teacher = summarizeStatusTeacher(report, options.providerConfig, localLlm);
     const liveModels = embeddings.models.length === 0 ? "none" : embeddings.models.join("|");
     const attachmentTruth = summarizeStatusAttachmentTruth({
         activationRoot: status.host.activationRoot,
@@ -1480,6 +1509,7 @@ function formatCurrentProfileStatusSummary(status, report, targetInspection, opt
         `host        runtime=${status.host.runtimeOwner} activation=${status.host.activationRoot}`,
         `profile     selector=${status.profile.selector}${profileIdSuffix} attachment=${status.attachment.state} policy=${status.attachment.policyMode}`,
         `guard       severity=${status.hook.guardSeverity} actionability=${status.hook.guardActionability} action=${status.hook.guardAction} summary=${status.hook.guardSummary}`,
+        `surfaceNote ${hotfixBoundary.detail}`,
         `attachTruth current=${attachmentTruth.currentProfileLabel} hook=${attachmentTruth.hookFiles} config=${attachmentTruth.configLoad} runtime=${attachmentTruth.runtimeLoad} watcher=${attachmentTruth.watcher} detail=${attachmentTruth.detail}`,
         `attachedSet ${formatAttachedProfileTruthDetailedList(attachmentTruth.attachedProfiles)} proofPath=${shortenPath(attachmentTruth.runtimeProofPath)} proofError=${attachmentTruth.runtimeProofError ?? "none"}`,
         `manyProfile surface=${report.manyProfile.operatorSurface} policy=${report.manyProfile.declaredAttachmentPolicy} intent=${report.manyProfile.sameGatewayIntent} checkedProof=${report.manyProfile.checkedInProofTopology} sameGatewayProof=${yesNo(report.manyProfile.sameGatewayProof)} sharedWriteProof=${yesNo(report.manyProfile.sharedWriteSafetyProof)}`,
@@ -1500,6 +1530,8 @@ function formatCurrentProfileStatusSummary(status, report, targetInspection, opt
             learningPath: report.learningPath,
             tracedLearning
         })}`,
+        `learnFlow   ${formatOperatorLearningFlowSummary({ tracedLearning })}`,
+        `health      ${formatOperatorLearningHealthSummary({ tracedLearning, teacher })}`,
         `feedback    ${formatOperatorFeedbackSummary({ tracedLearning })}`,
         `attribution ${formatOperatorLearningAttributionSummary({ status })}`,
         `attrCover   ${formatOperatorAttributionCoverageSummary({ tracedLearning })}`,
@@ -1692,8 +1724,7 @@ function inspectInstallConvergeVerification(parsed) {
         openclawHome: parsed.openclawHome,
         ...(targetInspection.profileId === null ? {} : { profileId: targetInspection.profileId })
     };
-    const status = describeCurrentProfileBrainStatus(operatorInput);
-    const report = buildOperatorSurfaceReport(operatorInput);
+    const { status, report } = describeCurrentProfileBrainStatusWithReport(operatorInput);
     const normalizedStatusAndReport = applyAttachmentPolicyTruth(status, report);
     const installHook = summarizeStatusInstallHook(parsed.openclawHome);
     const attachmentTruth = summarizeStatusAttachmentTruth({
@@ -4597,19 +4628,170 @@ function runUninstallCommand(parsed) {
     }
     return 0;
 }
-function resolveServeTimeLearningRuntimeInput(activationRoot) {
+function resolveServeTimeLearningRuntimeInput(activationRoot, normalizedEventExport = null) {
     const logPath = resolveLearningSpineLogPath(activationRoot, "serveTimeRouteDecisions");
-    const { entries: serveTimeDecisions, fallbackReason } = readBoundedJsonlTail(logPath);
+    const { entries: boundedServeTimeDecisions, fallbackReason } = readBoundedJsonlTail(logPath);
+    const historicalRecovery = fallbackReason === null
+        ? { decisions: [], scanFailed: false }
+        : readHistoricalServeTimeDecisions(logPath, collectServeTimeDecisionRecoveryTargets(normalizedEventExport));
+    const serveTimeDecisions = mergeHistoricalServeTimeDecisions(historicalRecovery.decisions, boundedServeTimeDecisions);
     const decisionLogCount = serveTimeDecisions.length;
     const pgVersion = decisionLogCount > 0 ? "v2" : "v1";
+    const resolvedFallbackReason = combineServeTimeLearningFallbackReasons(fallbackReason, historicalRecovery.scanFailed ? "historical_recovery_scan_failed" : null);
     return {
         pgVersion,
         serveTimeDecisions,
         decisionLogCount,
         baselineState: pgVersion === "v2" ? loadOrInitBaseline(activationRoot) : undefined,
-        fallbackReason: fallbackReason === null ? null : `serve_time_decision_log_${fallbackReason}`
+        fallbackReason: resolvedFallbackReason === null ? null : `serve_time_decision_log_${resolvedFallbackReason}`
     };
 }
+function combineServeTimeLearningFallbackReasons(...reasons) {
+    const resolved = reasons
+        .filter((reason) => typeof reason === "string" && reason.length > 0);
+    if (resolved.length === 0) {
+        return null;
+    }
+    return [...new Set(resolved.flatMap((reason) => reason.split("+").filter((part) => part.length > 0)))].join("+");
+}
+function mergeHistoricalServeTimeDecisions(historicalDecisions, boundedServeTimeDecisions) {
+    const merged = [];
+    const seenRecordIds = new Set();
+    for (const decision of [...historicalDecisions, ...boundedServeTimeDecisions]) {
+        const recordId = normalizeServeTimeDecisionRecoveryString(decision?.recordId);
+        if (recordId !== null) {
+            if (seenRecordIds.has(recordId)) {
+                continue;
+            }
+            seenRecordIds.add(recordId);
+        }
+        merged.push(decision);
+    }
+    return merged;
+}
+function readHistoricalServeTimeDecisions(logPath, targets) {
+    if (!hasServeTimeDecisionRecoveryTargets(targets)) {
+        return { decisions: [], scanFailed: false };
+    }
+    let raw;
+    try {
+        raw = readFileSync(logPath, "utf8");
+    }
+    catch {
+        return { decisions: [], scanFailed: true };
+    }
+    const decisions = [];
+    for (const line of raw.split(/\r?\n/u)) {
+        const trimmed = line.trim();
+        if (trimmed.length === 0) {
+            continue;
+        }
+        try {
+            const decision = JSON.parse(trimmed);
+            const recordId = normalizeServeTimeDecisionRecoveryString(decision?.recordId);
+            const selectionDigestKey = buildServeTimeDecisionRecoverySelectionKey(decision?.selectionDigest, decision?.activePackGraphChecksum);
+            const turnCompileEventId = normalizeServeTimeDecisionRecoveryString(decision?.turnCompileEventId);
+            if ((recordId !== null && targets.recordIds.has(recordId)) ||
+                (selectionDigestKey !== null && targets.selectionDigestKeys.has(selectionDigestKey)) ||
+                (turnCompileEventId !== null && targets.turnCompileEventIds.has(turnCompileEventId))) {
+                decisions.push(decision);
+            }
+        }
+        catch {
+            // skip malformed lines
+        }
+    }
+    return { decisions, scanFailed: false };
+}
+function hasServeTimeDecisionRecoveryTargets(targets) {
+    return targets.recordIds.size > 0 ||
+        targets.selectionDigestKeys.size > 0 ||
+        targets.turnCompileEventIds.size > 0;
+}
+function collectServeTimeDecisionRecoveryTargets(normalizedEventExport) {
+    const targets = {
+        recordIds: new Set(),
+        selectionDigestKeys: new Set(),
+        turnCompileEventIds: new Set()
+    };
+    const interactions = Array.isArray(normalizedEventExport?.interactionEvents)
+        ? normalizedEventExport.interactionEvents
+        : [];
+    const feedbackEvents = Array.isArray(normalizedEventExport?.feedbackEvents)
+        ? normalizedEventExport.feedbackEvents
+        : [];
+    const interactionsById = new Map();
+    for (const interaction of interactions) {
+        const interactionId = normalizeServeTimeDecisionRecoveryString(interaction?.eventId);
+        if (interactionId !== null && !interactionsById.has(interactionId)) {
+            interactionsById.set(interactionId, interaction);
+        }
+    }
+    const candidateInteractions = [];
+    for (const feedback of feedbackEvents) {
+        const relatedInteractionId = normalizeServeTimeDecisionRecoveryString(feedback?.relatedInteractionId);
+        if (relatedInteractionId === null) {
+            continue;
+        }
+        targets.turnCompileEventIds.add(relatedInteractionId);
+        const relatedInteraction = interactionsById.get(relatedInteractionId);
+        if (relatedInteraction !== undefined) {
+            candidateInteractions.push(relatedInteraction);
+        }
+    }
+    for (const interaction of candidateInteractions) {
+        const routeMetadata = readServeTimeDecisionRecoveryRecord(interaction?.routeMetadata);
+        const decisionProvenance = readServeTimeDecisionRecoveryRecord(interaction?.decisionProvenance);
+        const metadata = readServeTimeDecisionRecoveryRecord(interaction?.metadata);
+        const serveDecisionRecordId = normalizeServeTimeDecisionRecoveryString(interaction?.serveDecisionRecordId)
+            ?? normalizeServeTimeDecisionRecoveryString(routeMetadata?.serveDecisionRecordId)
+            ?? normalizeServeTimeDecisionRecoveryString(decisionProvenance?.serveDecisionRecordId)
+            ?? normalizeServeTimeDecisionRecoveryString(metadata?.serveDecisionRecordId);
+        if (serveDecisionRecordId !== null) {
+            targets.recordIds.add(serveDecisionRecordId);
+        }
+        const selectionDigestKey = buildServeTimeDecisionRecoverySelectionKey(normalizeServeTimeDecisionRecoveryString(interaction?.selectionDigest)
+            ?? normalizeServeTimeDecisionRecoveryString(routeMetadata?.selectionDigest)
+            ?? normalizeServeTimeDecisionRecoveryString(decisionProvenance?.selectionDigest)
+            ?? normalizeServeTimeDecisionRecoveryString(metadata?.selectionDigest), normalizeServeTimeDecisionRecoveryString(interaction?.activePackGraphChecksum)
+            ?? normalizeServeTimeDecisionRecoveryString(routeMetadata?.activePackGraphChecksum)
+            ?? normalizeServeTimeDecisionRecoveryString(decisionProvenance?.activePackGraphChecksum)
+            ?? normalizeServeTimeDecisionRecoveryString(metadata?.activePackGraphChecksum));
+        if (selectionDigestKey !== null) {
+            targets.selectionDigestKeys.add(selectionDigestKey);
+        }
+        const explicitTurnCompileEventId = normalizeServeTimeDecisionRecoveryString(interaction?.turnCompileEventId)
+            ?? normalizeServeTimeDecisionRecoveryString(routeMetadata?.turnCompileEventId)
+            ?? normalizeServeTimeDecisionRecoveryString(decisionProvenance?.turnCompileEventId)
+            ?? normalizeServeTimeDecisionRecoveryString(metadata?.turnCompileEventId);
+        if (explicitTurnCompileEventId !== null) {
+            targets.turnCompileEventIds.add(explicitTurnCompileEventId);
+        }
+        const softTurnCompileEventId = normalizeServeTimeDecisionRecoveryString(interaction?.eventId);
+        if (softTurnCompileEventId !== null) {
+            targets.turnCompileEventIds.add(softTurnCompileEventId);
+        }
+    }
+    return targets;
+}
+function readServeTimeDecisionRecoveryRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function normalizeServeTimeDecisionRecoveryString(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function buildServeTimeDecisionRecoverySelectionKey(selectionDigest, activePackGraphChecksum) {
+    const normalizedSelectionDigest = normalizeServeTimeDecisionRecoveryString(selectionDigest);
+    const normalizedGraphChecksum = normalizeServeTimeDecisionRecoveryString(activePackGraphChecksum);
+    if (normalizedSelectionDigest === null || normalizedGraphChecksum === null) {
+        return null;
+    }
+    return `${normalizedGraphChecksum}|${normalizedSelectionDigest}`;
+}
 function resolveActivationInspectionPackId(inspection, slot) {
     return inspection?.[slot]?.packId ?? inspection?.pointers?.[slot]?.packId ?? null;
 }
@@ -4855,7 +5037,7 @@ async function runLearnCommand(parsed) {
     }
     const learningExport = normalizedEventExport;
     const resolvedEmbedder = resolveCliEmbedderConfig(undefined, activationRoot);
-    const serveTimeLearning = resolveServeTimeLearningRuntimeInput(activationRoot);
+    const serveTimeLearning = resolveServeTimeLearningRuntimeInput(activationRoot, normalizedEventExport);
     const learnerResult = drainAlwaysOnLearningRuntime({
         packLabel: "learn-cli",
         workspace: {
@@ -5679,8 +5861,8 @@ export async function createWatchCommandRuntime(input) {
         },
         learnedRouting: true,
         ...(teacherLabeler !== null ? { teacherLabeler } : {}),
-        resolveLearnedRoutingState: () => {
-            const resolved = resolveServeTimeLearningRuntimeInput(activationRoot);
+        resolveLearnedRoutingState: (normalizedEventExport) => {
+            const resolved = resolveServeTimeLearningRuntimeInput(activationRoot, normalizedEventExport);
             if (resolved.fallbackReason !== null && resolved.fallbackReason !== lastServeTimeFallbackReason) {
                 log(`Serve-time routing fallback: ${resolved.fallbackReason}`);
             }
@@ -6364,13 +6546,16 @@ export function runOperatorCli(argv = process.argv.slice(2)) {
             : { profileId: targetInspection.profileId }),
         teacherSnapshotPath: resolveOperatorTeacherSnapshotPath(activationRoot, statusOrRollback.input.teacherSnapshotPath)
     };
-    const status = describeCurrentProfileBrainStatus(operatorInput);
+    const statusWithReport = describeCurrentProfileBrainStatusWithReport(operatorInput);
+    const status = statusWithReport.status;
     const tracedLearning = buildTracedLearningStatusSurface(activationRoot);
-    const normalizedStatusAndReport = applyAttachmentPolicyTruth(status, statusOrRollback.json ? null : buildOperatorSurfaceReport(operatorInput));
+    const normalizedStatusAndReport = applyAttachmentPolicyTruth(status, statusOrRollback.json ? null : statusWithReport.report);
+    const hotfixBoundaryTruth = summarizeStatusHotfixBoundary(normalizedStatusAndReport.status);
     if (statusOrRollback.json) {
         console.log(JSON.stringify({
             ...normalizedStatusAndReport.status,
-            tracedLearning
+            tracedLearning,
+            hotfixBoundaryTruth
         }, null, 2));
     }
     else {

package/dist/src/daemon.d.ts

@@ -46,6 +46,8 @@ export interface ManagedLearnerServiceInspection {
     configuredCommand: string | null;
     configuredRuntimePath: string | null;
     configuredRuntimePackageSpec: string | null;
+    configuredRuntimePackageName: string | null;
+    configuredRuntimePackageVersion: string | null;
     configuredRuntimeLooksEphemeral: boolean | null;
     matchesRequestedActivationRoot: boolean | null;
     launchctlAvailable: boolean;

package/dist/src/daemon.js

@@ -306,6 +306,17 @@ export function describeManagedLearnerServiceRuntimeGuard(inspection) {
         detail: `Learner service points at the durable ${CLI_PACKAGE_NAME} runtime.`
     };
 }
+function buildDaemonHotfixBoundary(inspection) {
+    return {
+        surface: "daemon_runtime",
+        separateFromInstalledHookSurface: true,
+        runtimePath: inspection.configuredRuntimePath ?? null,
+        guidance: "Patch this daemon runtime path for background watch/learner fixes. Use `openclawbrain status --openclaw-home <path> --detailed` to inspect the separate installed hook/runtime-guard surface before patching OpenClaw load behavior.",
+        detail: inspection.configuredRuntimePath === null
+            ? "daemon status is only reporting the background watch surface; no configured runtime path is visible yet."
+            : `daemon status is reporting the background watch runtime at ${inspection.configuredRuntimePath}; installed hook/runtime-guard paths live on the OpenClaw profile side.`
+    };
+}
 function resolveDaemonProgramArguments() {
     for (const candidate of getOpenclawbrainCliScriptPathCandidates()) {
         const cliScriptPath = resolveCliScriptCandidate(candidate);
@@ -970,6 +981,11 @@ export function daemonStatus(activationRoot, json) {
         ? null
         : canonicalizeActivationRoot(configuredActivationRoot) === serviceIdentity.canonicalActivationRoot;
     const daemonLaunchDescription = describeDaemonProgramArguments(configuredProgramArguments);
+    const hotfixBoundary = buildDaemonHotfixBoundary({
+        installed: plistInstalled,
+        configuredProgramArguments,
+        ...daemonLaunchDescription,
+    });
     if (json) {
         console.log(JSON.stringify({
             command: "daemon status",
@@ -986,6 +1002,7 @@ export function daemonStatus(activationRoot, json) {
             ...watchStatePaths,
             watchState,
             lastLogLines,
+            hotfixBoundary,
         }, null, 2));
     }
     else {
@@ -1015,6 +1032,8 @@ export function daemonStatus(activationRoot, json) {
             const runtimeWarning = daemonLaunchDescription.configuredRuntimeLooksEphemeral ? " [ephemeral]" : "";
             console.log(`  Runtime: ${daemonLaunchDescription.configuredRuntimePath}${runtimePackageSuffix}${runtimeWarning}`);
         }
+        console.log("  Runtime surface: daemon watch/learner runtime");
+        console.log(`  Hotfix boundary: ${hotfixBoundary.guidance}`);
         const runtimeGuard = describeManagedLearnerServiceRuntimeGuard({
             installed: plistInstalled,
             configuredProgramArguments,

package/dist/src/index.d.ts

@@ -1,8 +1,8 @@
 import { type CompileSelectionMode } from "@openclawbrain/compiler";
 import { CONTRACT_IDS, type ArtifactManifestV1, type ActivationPointerRecordV1, type ActivationPointerSlot, type RuntimeTurnBrainAttachmentPolicyV1, type ContextCompactionMode, type ContextContributionEvidenceStateV1, type CurrentProfileBrainStatusAnswerV1, type CurrentProfileActivationStateV1, type CurrentProfilePassiveLearningDeltaSummaryV1, type CurrentProfilePassiveLearningWatchStateV1, type CurrentProfileAttachmentStateV1, type CurrentProfileAttachmentProofStateV1, type CurrentProfileHookInstallStateV1, type CurrentProfileHookLoadabilityV1, type CurrentProfileHookLoadProofV1, type BrainServeHotPathTimingV1, type CurrentProfileStructuralDecisionV1, type FeedbackEventKind, type PackGraphConnectDiagnosticsV1, type PackGraphEvolutionV1, type EventSemanticSurfaceV1, type FeedbackEventV1, type KernelSurfaceValidationResultV1, type LearningBootProfile, type LearningCadence, type LearningScanPolicy, type InteractionEventV1, type NormalizedEventExportV1, type NormalizedEventV1, type PrincipalPriorityClassV1, type PrincipalRoleV1, type RouteMode, type RuntimeCompileResponseV1, type RuntimeCompileStructuralSignalsV1, type RuntimeCompileTargetV1, type RuntimeGraphPlasticityStateV1, type RuntimePlasticitySourceV1, type SparseFeedbackPolicyV1, type TeacherAuthorityV1, type TeacherSupervisionArtifactV1, type WorkspaceInjectionSurfaceV1 } from "@openclawbrain/contracts";
 import { type EventExportLaneV1 } from "@openclawbrain/event-export";
-import { type AdvanceAlwaysOnLearningRuntimeInput, type AlwaysOnLearningCadenceV1, type AlwaysOnLearningMaterializationJobV1, type AlwaysOnLearningRuntimePlanV1, type AlwaysOnLearningRuntimeStateV1, type BaselineStateV1, type PendingPrincipalEventV1, type PrincipalLearningCheckpointV1 } from "./local-learner.js";
-import { type ActivationInspection, type ActivationObservabilityReport, type GraphEvolutionLogV1, type LearningSpineServeRouteBreadcrumbsV1, type ActivationSlotInspection, type InitHandoffState, type LearningSpineServeRouteDecisionLogEntryV1 } from "@openclawbrain/pack-format";
+import { type AdvanceAlwaysOnLearningRuntimeInput, type AlwaysOnLearningCadenceV1, type AlwaysOnLearningMaterializationJobV1, type AlwaysOnLearningRuntimePlanV1, type AlwaysOnLearningRuntimeStateV1, type BaselineStateV1, type PendingPrincipalEventV1, type PrincipalLearningCheckpointV1, type LearningSpineServeRouteDecisionLogEntryV1 } from "./local-learner.js";
+import { type ActivationInspection, type ActivationObservabilityReport, type GraphEvolutionLogV1, type LearningSpineServeRouteBreadcrumbsV1, type ActivationSlotInspection, type InitHandoffState } from "@openclawbrain/pack-format";
 export { clearOpenClawProfileRuntimeLoadProof, listOpenClawProfileRuntimeLoadProofs, recordOpenClawProfileRuntimeLoadProof, resolveAttachmentRuntimeLoadProofsPath, type OpenClawProfileRuntimeLoadProofRecordV1, type OpenClawProfileRuntimeLoadProofSetV1, type OpenClawProfileRuntimeLoadProofsV1 } from "./attachment-truth.js";
 import { type AsyncTeacherLabelerConfigV1 } from "./teacher-labeler.js";
 export { createHttpOllamaTeacherLabelerClient, createOllamaTeacherLabeler, createTeacherLabeler, summarizeTeacherLabelerOpportunity, type AsyncTeacherLabelerConfigV1, type AsyncTeacherNoopLabelerConfigV1, type AsyncTeacherOllamaLabelerConfigV1, type OllamaTeacherLabelerClient, type TeacherLabeler, type TeacherLabelerOpportunityInputV1, type TeacherLabelerOpportunityV1, type TeacherLabelerResultV1, type TeacherLabelerRunInputV1 } from "./teacher-labeler.js";

package/dist/src/index.js

@@ -904,7 +904,7 @@ export class AsyncTeacherLiveLoop {
                     interactionEvents: this.interactionEvents,
                     feedbackEvents: this.feedbackEvents
                 });
-                const learnedRoutingState = this.input.resolveLearnedRoutingState?.() ?? {};
+                const learnedRoutingState = this.input.resolveLearnedRoutingState?.(mergedNormalizedEventExport) ?? {};
                 const currentDedupIds = new Set(this.teacherArtifacts.map((artifact) => artifact.dedupId));
                 const currentCycleBuiltArtifacts = buildTeacherSupervisionArtifactsFromNormalizedEventExport({
                     normalizedEventExport: job.normalizedEventExport,
@@ -8031,9 +8031,15 @@ export function buildOperatorSurfaceReport(input) {
         findings
     };
 }
-export function describeCurrentProfileBrainStatus(input) {
+export function describeCurrentProfileBrainStatusWithReport(input) {
     const report = buildOperatorSurfaceReport(input);
-    return buildCurrentProfileBrainStatusFromReport(report, report.manyProfile.declaredAttachmentPolicy, normalizeOptionalString(input.profileId) ?? null);
+    return {
+        report,
+        status: buildCurrentProfileBrainStatusFromReport(report, report.manyProfile.declaredAttachmentPolicy, normalizeOptionalString(input.profileId) ?? null)
+    };
+}
+export function describeCurrentProfileBrainStatus(input) {
+    return describeCurrentProfileBrainStatusWithReport(input).status;
 }
 export function formatOperatorRollbackReport(result) {
     const header = result.allowed ? (result.dryRun ? "ROLLBACK ready" : "ROLLBACK ok") : "ROLLBACK blocked";

package/dist/src/learning-spine.d.ts

@@ -1,6 +1,7 @@
 import { type AlwaysOnLearningMaterializationJobV1 } from "@openclawbrain/learner";
 import { type BrainServeHotPathTimingV1, type NormalizedEventExportV1, type RouteMode, type RuntimeCompileResponseV1 } from "@openclawbrain/contracts";
-import { type LearningSpinePgRouteUpdateLogEntryV1, type LearningSpineServeRouteBreadcrumbsV1, type LearningSpineServeRouteDecisionLogEntryV1, type PackDescriptor } from "@openclawbrain/pack-format";
+import { type LearningSpinePgRouteUpdateLogEntryV1, type LearningSpineServeRouteBreadcrumbsV1, type PackDescriptor } from "@openclawbrain/pack-format";
+import { type LearningSpineServeRouteDecisionLogEntryV1 } from "./local-learner.js";
 type CompileFailureLike = {
     ok: false;
     fallbackToStaticContext: boolean;

package/dist/src/local-learner.d.ts

@@ -1,8 +1,24 @@
 import { type ArtifactManifestV1, type FeedbackEventV1, type InteractionEventV1, type NormalizedEventExportV1, type NormalizedEventV1, type PrincipalPriorityClassV1, type PrincipalRoleV1, type PackGraphPayloadV1, type PackVectorsPayloadV1, type RouterArtifactV1, type RouterPolicyUpdateV1, type RuntimeCompileStructuralSignalsV1, type RuntimeGraphPlasticityStateV1, type SparseFeedbackPolicyV1, type TeacherSupervisionArtifactV1 } from "@openclawbrain/contracts";
 import { type EventExportCursorV1, type EventExportLaneV1, type NormalizedEventExportBridgeV1, type NormalizedEventExportSliceV1 } from "@openclawbrain/event-export";
 import type { TextEmbedder } from "@openclawbrain/compiler";
-import { type PackDescriptor, type GraphEvolutionLogV1, type LearningSpineServeRouteDecisionLogEntryV1 } from "@openclawbrain/pack-format";
+import { type PackDescriptor, type GraphEvolutionLogV1, type LearningSpineServeRouteDecisionLogEntryV1 as PackFormatLearningSpineServeRouteDecisionLogEntryV1 } from "@openclawbrain/pack-format";
 import { type WorkspaceMetadataInput } from "@openclawbrain/workspace-metadata";
+export interface LearningSpineServeRouteCandidateScoreV1 {
+    blockId: string;
+    selected: boolean;
+    actionScore: number;
+    actionProbability: number;
+    compactedFrom?: string[];
+    matchedTokens?: string[];
+    routingChannels?: string[];
+}
+export type LearningSpineServeRouteDecisionLogEntryV1 = Omit<PackFormatLearningSpineServeRouteDecisionLogEntryV1, "candidateSetIds" | "chosenContextIds" | "candidateScores" | "selectedKernelContextIds" | "selectedBrainContextIds"> & {
+    candidateSetIds: string[];
+    chosenContextIds: string[];
+    candidateScores: LearningSpineServeRouteCandidateScoreV1[];
+    selectedKernelContextIds: string[];
+    selectedBrainContextIds: string[];
+};
 export interface CandidatePackEventExports {
     interactionEvents: InteractionEventV1[];
     feedbackEvents: FeedbackEventV1[];