@openclawbrain/cli 0.4.26 → 0.4.28

package/dist/src/cli.js

@@ -13,7 +13,7 @@ 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";
@@ -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 })}`,
@@ -4596,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;
 }
@@ -4854,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: {
@@ -5678,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}`);
             }
@@ -6367,10 +6550,12 @@ export function runOperatorCli(argv = process.argv.slice(2)) {
     const status = statusWithReport.status;
     const tracedLearning = buildTracedLearningStatusSurface(activationRoot);
     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,

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[];

package/dist/src/local-learner.js

@@ -455,6 +455,98 @@ function normalizeTeacherSupervisionArtifacts(artifacts) {
         .filter((artifact) => !artifact.sourceEventIds.some((eventId) => supersededEventIds.has(eventId)))
         .sort(compareTeacherSupervisionArtifacts);
 }
+function normalizeServeTimeDecisionStringArray(values) {
+    if (!Array.isArray(values)) {
+        return [];
+    }
+    return values.filter((value) => typeof value === "string" && value.length > 0);
+}
+function normalizeServeTimeDecisionScore(score) {
+    if (score === null || typeof score !== "object" || Array.isArray(score)) {
+        return null;
+    }
+    if (typeof score.blockId !== "string" || score.blockId.length === 0) {
+        return null;
+    }
+    return {
+        blockId: score.blockId,
+        selected: score.selected === true,
+        actionScore: Number.isFinite(score.actionScore) ? score.actionScore : 0,
+        actionProbability: Number.isFinite(score.actionProbability) ? score.actionProbability : 0,
+        ...(Array.isArray(score.compactedFrom) ? { compactedFrom: normalizeServeTimeDecisionStringArray(score.compactedFrom) } : {}),
+        ...(Array.isArray(score.matchedTokens) ? { matchedTokens: normalizeServeTimeDecisionStringArray(score.matchedTokens) } : {}),
+        ...(Array.isArray(score.routingChannels) ? { routingChannels: normalizeServeTimeDecisionStringArray(score.routingChannels) } : {})
+    };
+}
+function normalizeServeTimeDecisionLogEntry(decision) {
+    if (decision === null || typeof decision !== "object" || Array.isArray(decision)) {
+        return null;
+    }
+    const selectedKernelContextIds = normalizeServeTimeDecisionStringArray(decision.selectedKernelContextIds);
+    const selectedBrainContextIds = normalizeServeTimeDecisionStringArray(decision.selectedBrainContextIds);
+    return {
+        ...decision,
+        candidateSetIds: normalizeServeTimeDecisionStringArray(decision.candidateSetIds),
+        chosenContextIds: normalizeServeTimeDecisionStringArray(decision.chosenContextIds),
+        candidateScores: Array.isArray(decision.candidateScores)
+            ? decision.candidateScores.map((score) => normalizeServeTimeDecisionScore(score)).filter((score) => score !== null)
+            : [],
+        kernelContextCount: Number.isInteger(decision.kernelContextCount) && decision.kernelContextCount >= 0
+            ? decision.kernelContextCount
+            : selectedKernelContextIds.length,
+        brainContextCount: Number.isInteger(decision.brainContextCount) && decision.brainContextCount >= 0
+            ? decision.brainContextCount
+            : selectedBrainContextIds.length,
+        selectedKernelContextIds,
+        selectedBrainContextIds
+    };
+}
+function normalizeServeTimeDecisionsForLearner(serveTimeDecisions) {
+    if (serveTimeDecisions === undefined) {
+        return undefined;
+    }
+    if (!Array.isArray(serveTimeDecisions)) {
+        return [];
+    }
+    return serveTimeDecisions
+        .map((decision) => normalizeServeTimeDecisionLogEntry(decision))
+        .filter((decision) => decision !== null);
+}
+function projectServeTimeDecisionForRoutingSeed(decision) {
+    return {
+        recordId: typeof decision.recordId === "string" ? decision.recordId : null,
+        recordedAt: typeof decision.recordedAt === "string" ? decision.recordedAt : null,
+        sessionId: typeof decision.sessionId === "string" ? decision.sessionId : null,
+        channel: typeof decision.channel === "string" ? decision.channel : null,
+        turnCompileEventId: typeof decision.turnCompileEventId === "string" ? decision.turnCompileEventId : null,
+        turnCreatedAt: typeof decision.turnCreatedAt === "string" ? decision.turnCreatedAt : null,
+        activePackId: typeof decision.activePackId === "string" ? decision.activePackId : null,
+        activePackGraphChecksum: typeof decision.activePackGraphChecksum === "string" ? decision.activePackGraphChecksum : null,
+        routerIdentity: typeof decision.routerIdentity === "string" ? decision.routerIdentity : null,
+        selectionDigest: typeof decision.selectionDigest === "string" ? decision.selectionDigest : null,
+        usedLearnedRouteFn: decision.usedLearnedRouteFn === true,
+        fallbackReason: typeof decision.fallbackReason === "string" ? decision.fallbackReason : null,
+        candidateSetIds: decision.candidateSetIds,
+        chosenContextIds: decision.chosenContextIds,
+        candidateScores: decision.candidateScores.map((score) => ({
+            blockId: score.blockId,
+            selected: score.selected,
+            actionScore: score.actionScore,
+            actionProbability: score.actionProbability,
+            compactedFrom: score.compactedFrom ?? []
+        })),
+        kernelContextCount: decision.kernelContextCount,
+        brainContextCount: decision.brainContextCount,
+        selectedKernelContextIds: decision.selectedKernelContextIds,
+        selectedBrainContextIds: decision.selectedBrainContextIds
+    };
+}
+function checksumServeTimeDecisionsForRoutingSeed(serveTimeDecisions) {
+    if (serveTimeDecisions === undefined) {
+        return null;
+    }
+    return checksumJsonPayload(serveTimeDecisions.map((decision) => projectServeTimeDecisionForRoutingSeed(decision)));
+}
 function teacherSupervisionContentForInteraction(event) {
     const message = event.messageId === undefined ? "" : ` Message: ${event.messageId}.`;
     const pack = event.packId === undefined ? "" : ` Pack: ${event.packId}.`;
@@ -893,7 +985,7 @@ function buildAlwaysOnLearningMaterializationJob(input, current, selectedSlices,
         ...(input.sparseFeedback !== undefined ? { sparseFeedback: input.sparseFeedback } : {}),
         principalBacklog,
         ...(input.pgVersion !== undefined ? { pgVersion: input.pgVersion } : {}),
-        ...(input.serveTimeDecisions !== undefined ? { serveTimeDecisions: [...input.serveTimeDecisions] } : {}),
+        ...(input.serveTimeDecisions !== undefined ? { serveTimeDecisions: normalizeServeTimeDecisionsForLearner(input.serveTimeDecisions) } : {}),
         ...(input.baselineState !== undefined ? { baselineState: { ...input.baselineState } } : {}),
         ...(input.activationRoot !== undefined ? { activationRoot: input.activationRoot } : {})
     };
@@ -1049,7 +1141,7 @@ export function buildCandidatePackFromNormalizedEventExportSlice(input) {
         ...(input.sparseFeedback !== undefined ? { sparseFeedback: input.sparseFeedback } : {}),
         ...(input.principalBacklog !== undefined ? { principalBacklog: input.principalBacklog } : {}),
         ...(input.pgVersion !== undefined ? { pgVersion: input.pgVersion } : {}),
-        ...(input.serveTimeDecisions !== undefined ? { serveTimeDecisions: [...input.serveTimeDecisions] } : {}),
+        ...(input.serveTimeDecisions !== undefined ? { serveTimeDecisions: normalizeServeTimeDecisionsForLearner(input.serveTimeDecisions) } : {}),
         ...(input.baselineState !== undefined ? { baselineState: { ...input.baselineState } } : {})
     });
 }
@@ -1080,7 +1172,7 @@ export function buildCandidatePackBundleFromNormalizedEventExportBridge(input) {
                 ...(input.sparseFeedback !== undefined ? { sparseFeedback: input.sparseFeedback } : {}),
                 ...(input.principalBacklog !== undefined ? { principalBacklog: input.principalBacklog } : {}),
                 ...(input.pgVersion !== undefined ? { pgVersion: input.pgVersion } : {}),
-                ...(input.serveTimeDecisions !== undefined ? { serveTimeDecisions: [...input.serveTimeDecisions] } : {}),
+                ...(input.serveTimeDecisions !== undefined ? { serveTimeDecisions: normalizeServeTimeDecisionsForLearner(input.serveTimeDecisions) } : {}),
                 ...(input.baselineState !== undefined ? { baselineState: { ...input.baselineState } } : {})
             })
         };
@@ -3565,7 +3657,8 @@ function remapServeTimeDecisionToGraph(decision, resolveBlockId) {
     const remappedSelectedBrainContextIds = remapIds(decision.selectedBrainContextIds);
     const chosenSet = new Set(remappedChosenContextIds);
     const remappedScoresByBlockId = new Map();
-    for (const score of decision.candidateScores) {
+    const candidateScores = Array.isArray(decision.candidateScores) ? decision.candidateScores : [];
+    for (const score of candidateScores) {
         const resolvedBlockId = resolveBlockId(score.blockId);
         if (resolvedBlockId === null) {
             continue;
@@ -4540,13 +4633,15 @@ function buildGraphLocalActionSetFromScores(nodeBlockId, neighborBlockIds, graph
  * Traces through the graph starting from the highest-scoring selected block.
  */
 export function reconstructTrajectoryFromServeDecision(decision, graph, vectors, adjacency, tau, outcome, baselineValue) {
-    const chosenSet = new Set(decision.chosenContextIds);
+    const chosenContextIds = Array.isArray(decision.chosenContextIds) ? decision.chosenContextIds : [];
+    const candidateScores = Array.isArray(decision.candidateScores) ? decision.candidateScores : [];
+    const chosenSet = new Set(chosenContextIds);
     const candidateScoresMap = new Map();
-    for (const cs of decision.candidateScores) {
+    for (const cs of candidateScores) {
         candidateScoresMap.set(cs.blockId, cs.actionScore);
     }
     // Sort chosen blocks by score descending to find entry point
-    const chosenWithScores = decision.chosenContextIds
+    const chosenWithScores = chosenContextIds
         .map((blockId) => ({ blockId, score: candidateScoresMap.get(blockId) ?? 0 }))
         .sort((a, b) => b.score - a.score);
     const steps = [];
@@ -4679,7 +4774,7 @@ function createRouterArtifactV2(packId, builtAt, graph, vectors, eventExport, se
     // 1. Build adjacency map from graph
     const adjacency = buildAdjacencyMap(graph);
     const resolveBlockId = buildGraphBlockIdResolver(graph);
-    const remappedServeTimeDecisions = serveTimeDecisions.map((decision) => remapServeTimeDecisionToGraph(decision, resolveBlockId));
+    const remappedServeTimeDecisions = (serveTimeDecisions ?? []).map((decision) => remapServeTimeDecisionToGraph(decision, resolveBlockId));
     // 2. Join serve-time decisions with explicit feedback first, then let teacher-v2 observations override when available.
     const outcomeMap = joinDecisionsWithFeedback(remappedServeTimeDecisions, eventExport);
     const teacherObservationBindings = joinDecisionsWithTeacherObservationOutcomes(remappedServeTimeDecisions, teacherObservationOutcomes);
@@ -4710,7 +4805,7 @@ function createRouterArtifactV2(packId, builtAt, graph, vectors, eventExport, se
             `traj-${stableHash(checksumJsonPayload({ decisionId: d.recordId, steps: trajectory.steps.map((s) => s.nodeBlockId) }))}` === trajectory.trajectoryId);
         const candidateScoresMap = new Map();
         if (decision !== undefined) {
-            for (const cs of decision.candidateScores) {
+            for (const cs of decision.candidateScores ?? []) {
                 candidateScoresMap.set(cs.blockId, cs.actionScore);
             }
         }
@@ -5000,7 +5095,8 @@ export function buildCandidatePack(input) {
     });
     const learningSurface = eventExport?.provenance.learningSurface ?? defaultLearningSurface(workspace, offlineArtifacts, workspaceInit);
     const sparseFeedback = normalizeSparseFeedbackPolicy(input.sparseFeedback);
-    const decisionLogCount = input.serveTimeDecisions?.length ?? 0;
+    const serveTimeDecisions = normalizeServeTimeDecisionsForLearner(input.serveTimeDecisions);
+    const decisionLogCount = serveTimeDecisions?.length ?? 0;
     const useV2 = input.pgVersion === "v2" && decisionLogCount > 0;
     const fallbackReason = !input.learnedRouting
         ? null
@@ -5010,7 +5106,7 @@ export function buildCandidatePack(input) {
     const routingSeed = input.learnedRouting && (input.pgVersion === "v2" || decisionLogCount > 0 || input.baselineState !== undefined)
         ? {
             pgVersionRequested: input.pgVersion ?? "v1",
-            serveTimeDecisionDigest: input.serveTimeDecisions === undefined ? null : checksumJsonPayload(input.serveTimeDecisions),
+            serveTimeDecisionDigest: checksumServeTimeDecisionsForRoutingSeed(serveTimeDecisions),
             baselineState: input.baselineState ?? null
         }
         : null;
@@ -5048,7 +5144,7 @@ export function buildCandidatePack(input) {
         : loadTeacherObservationOutcomesFromActivation(input.activationRoot);
     if (input.learnedRouting) {
         if (useV2) {
-            const v2Result = createRouterArtifactV2(packId, builtAt, graph, vectors, eventExport, input.serveTimeDecisions, input.baselineState ?? initBaseline(), input.sparseFeedback, input.principalBacklog, teacherObservationOutcomes);
+            const v2Result = createRouterArtifactV2(packId, builtAt, graph, vectors, eventExport, serveTimeDecisions ?? [], input.baselineState ?? initBaseline(), input.sparseFeedback, input.principalBacklog, teacherObservationOutcomes);
             router = v2Result.artifact;
             updatedBaseline = v2Result.updatedBaseline;
             observationBindingStats = v2Result.observationBindingStats;
@@ -5211,7 +5307,7 @@ export function buildCandidatePackFromNormalizedEventExport(input) {
         ...(input.sparseFeedback !== undefined ? { sparseFeedback: input.sparseFeedback } : {}),
         ...(input.principalBacklog !== undefined ? { principalBacklog: input.principalBacklog } : {}),
         ...(input.pgVersion !== undefined ? { pgVersion: input.pgVersion } : {}),
-        ...(input.serveTimeDecisions !== undefined ? { serveTimeDecisions: [...input.serveTimeDecisions] } : {}),
+        ...(input.serveTimeDecisions !== undefined ? { serveTimeDecisions: normalizeServeTimeDecisionsForLearner(input.serveTimeDecisions) } : {}),
         ...(input.baselineState !== undefined ? { baselineState: { ...input.baselineState } } : {}),
         ...(input.activationRoot !== undefined ? { activationRoot: input.activationRoot } : {})
     };

package/dist/src/openclaw-hook-truth.d.ts

@@ -16,6 +16,7 @@ export interface OpenClawBrainHookInspection {
     manifestId: string | null;
     installId: string | null;
     packageName: string | null;
+    packageVersion: string | null;
     installLayout: OpenClawBrainInstallLayout | null;
     additionalInstallCount: number;
     installState: OpenClawBrainHookInstallState;
@@ -31,9 +32,30 @@ export interface OpenClawBrainHookLoadSummary extends OpenClawBrainHookInspectio
     guardSummary: string;
     guardAction: string;
 }
+export interface OpenClawBrainDaemonRuntimeSurfaceInspection {
+    configuredRuntimePath: string | null;
+    configuredRuntimePackageSpec?: string | null;
+    configuredRuntimePackageName?: string | null;
+    configuredRuntimePackageVersion?: string | null;
+}
+export interface OpenClawBrainHotfixBoundarySummary {
+    boundary: string;
+    skew: string;
+    daemonPath: string | null;
+    hookPath: string | null;
+    runtimeGuardPath: string | null;
+    daemonPackage: string | null;
+    hookPackage: string | null;
+    guidance: string;
+    detail: string;
+}
 export declare function inspectOpenClawBrainPluginAllowlist(openclawHome: string): {
     state: Exclude<OpenClawBrainPluginAllowlistState, "unverified">;
     detail: string;
 };
 export declare function inspectOpenClawBrainHookStatus(openclawHome: string | null | undefined): OpenClawBrainHookInspection;
 export declare function summarizeOpenClawBrainHookLoad(inspection: OpenClawBrainHookInspection, statusProbeReady: boolean): OpenClawBrainHookLoadSummary;
+export declare function describeOpenClawBrainHotfixBoundary(input: {
+    hookInspection: OpenClawBrainHookInspection;
+    daemonInspection?: OpenClawBrainDaemonRuntimeSurfaceInspection | null;
+}): OpenClawBrainHotfixBoundarySummary;

package/dist/src/openclaw-hook-truth.js

@@ -35,6 +35,37 @@ function shortenPath(fullPath) {
     }
     return fullPath;
 }
+function readInstalledHookPackageVersion(packageJsonPath) {
+    if (typeof packageJsonPath !== "string" || packageJsonPath.trim().length === 0) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+        return typeof parsed?.version === "string" && parsed.version.trim().length > 0
+            ? parsed.version.trim()
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function formatPackageIdentity(packageName, packageVersion, packageSpec = null) {
+    if (typeof packageSpec === "string" && packageSpec.trim().length > 0) {
+        return packageSpec.trim();
+    }
+    if (typeof packageName !== "string" || packageName.trim().length === 0) {
+        return null;
+    }
+    const normalizedName = packageName.trim();
+    return typeof packageVersion === "string" && packageVersion.trim().length > 0
+        ? `${normalizedName}@${packageVersion.trim()}`
+        : normalizedName;
+}
+function normalizeSurfacePath(filePath) {
+    return typeof filePath === "string" && filePath.trim().length > 0
+        ? path.resolve(filePath)
+        : null;
+}
 function inspectInstalledHookActivationRoot(loaderEntryPath) {
     let content;
     try {
@@ -147,6 +178,7 @@ export function inspectOpenClawBrainHookStatus(openclawHome) {
             manifestId: null,
             installId: null,
             packageName: null,
+            packageVersion: null,
             installLayout: null,
             additionalInstallCount: 0,
             installState: "unverified",
@@ -173,6 +205,7 @@ export function inspectOpenClawBrainHookStatus(openclawHome) {
             manifestId: incompleteInstall?.manifestId ?? null,
             installId: incompleteInstall?.installId ?? null,
             packageName: incompleteInstall?.packageName ?? null,
+            packageVersion: readInstalledHookPackageVersion(incompleteInstall?.packageJsonPath ?? null),
             installLayout: incompleteInstall?.installLayout ?? null,
             additionalInstallCount: installedPlugin.additionalInstalls.length,
             installState: "not_installed",
@@ -189,6 +222,7 @@ export function inspectOpenClawBrainHookStatus(openclawHome) {
     const allowlist = inspectOpenClawBrainPluginAllowlist(resolvedHome);
     const layoutLabel = describeOpenClawBrainInstallLayout(selectedInstall.installLayout);
     const identityDetail = describeOpenClawBrainInstallIdentity(selectedInstall);
+    const packageVersion = readInstalledHookPackageVersion(selectedInstall.packageJsonPath);
     const activationRootState = inspectInstalledHookActivationRoot(selectedInstall.loaderEntryPath);
     if (allowlist.state === "blocked") {
         return {
@@ -202,6 +236,7 @@ export function inspectOpenClawBrainHookStatus(openclawHome) {
             manifestId: selectedInstall.manifestId,
             installId: selectedInstall.installId,
             packageName: selectedInstall.packageName,
+            packageVersion,
             installLayout: selectedInstall.installLayout,
             additionalInstallCount: installedPlugin.additionalInstalls.length,
             installState: "blocked_by_allowlist",
@@ -224,6 +259,7 @@ export function inspectOpenClawBrainHookStatus(openclawHome) {
             manifestId: selectedInstall.manifestId,
             installId: selectedInstall.installId,
             packageName: selectedInstall.packageName,
+            packageVersion,
             installLayout: selectedInstall.installLayout,
             additionalInstallCount: installedPlugin.additionalInstalls.length,
             installState: "blocked_by_allowlist",
@@ -246,6 +282,7 @@ export function inspectOpenClawBrainHookStatus(openclawHome) {
             manifestId: selectedInstall.manifestId,
             installId: selectedInstall.installId,
             packageName: selectedInstall.packageName,
+            packageVersion,
             installLayout: selectedInstall.installLayout,
             additionalInstallCount: installedPlugin.additionalInstalls.length,
             installState: "installed",
@@ -266,6 +303,7 @@ export function inspectOpenClawBrainHookStatus(openclawHome) {
         manifestId: selectedInstall.manifestId,
         installId: selectedInstall.installId,
         packageName: selectedInstall.packageName,
+        packageVersion,
         installLayout: selectedInstall.installLayout,
         additionalInstallCount: installedPlugin.additionalInstalls.length,
         installState: "installed",
@@ -284,4 +322,83 @@ export function summarizeOpenClawBrainHookLoad(inspection, statusProbeReady) {
             : "not_ready"
     };
 }
+export function describeOpenClawBrainHotfixBoundary(input) {
+    const hookInspection = input.hookInspection;
+    const daemonInspection = input.daemonInspection ?? null;
+    const daemonPath = normalizeSurfacePath(daemonInspection?.configuredRuntimePath ?? null);
+    const hookPath = normalizeSurfacePath(hookInspection.hookPath);
+    const runtimeGuardPath = normalizeSurfacePath(hookInspection.runtimeGuardPath);
+    const daemonPackage = formatPackageIdentity(daemonInspection?.configuredRuntimePackageName ?? null, daemonInspection?.configuredRuntimePackageVersion ?? null, daemonInspection?.configuredRuntimePackageSpec ?? null);
+    const hookPackage = formatPackageIdentity(hookInspection.packageName, hookInspection.packageVersion);
+    if (hookInspection.scope === "activation_root_only") {
+        return {
+            boundary: "hook_surface_unverified",
+            skew: "unverified",
+            daemonPath,
+            hookPath: null,
+            runtimeGuardPath: null,
+            daemonPackage,
+            hookPackage: null,
+            guidance: "Pin --openclaw-home before patching the installed hook/runtime-guard surface; activation-root-only status does not prove which OpenClaw install you would be changing.",
+            detail: daemonPath === null
+                ? "activation-root-only status does not expose the installed hook/runtime-guard surface."
+                : `daemon runtime path ${shortenPath(daemonPath)} is visible, but activation-root-only status still does not expose the installed hook/runtime-guard surface.`
+        };
+    }
+    if (hookPath === null && runtimeGuardPath === null) {
+        return {
+            boundary: "hook_surface_unverified",
+            skew: "unverified",
+            daemonPath,
+            hookPath: null,
+            runtimeGuardPath: null,
+            daemonPackage,
+            hookPackage,
+            guidance: daemonPath === null
+                ? "Repair or reinstall the installed hook surface before patching OpenClaw load behavior."
+                : "Patch the daemon runtime path for background watch fixes, but repair or reinstall the installed hook/runtime-guard surface before patching OpenClaw load behavior.",
+            detail: daemonPath === null
+                ? "no verified daemon runtime path or installed hook/runtime-guard path is visible from this status snapshot."
+                : `daemon runtime path ${shortenPath(daemonPath)} is visible, but the installed hook/runtime-guard surface is not yet loadable.`
+        };
+    }
+    if (daemonPath === null) {
+        return {
+            boundary: "daemon_surface_only",
+            skew: "unverified",
+            daemonPath: null,
+            hookPath,
+            runtimeGuardPath,
+            daemonPackage: null,
+            hookPackage,
+            guidance: "Patch the installed hook/runtime-guard surface for OpenClaw load fixes. No configured daemon runtime path is visible from status.",
+            detail: `installed hook loads from ${hookPath === null ? "unverified" : shortenPath(hookPath)}${runtimeGuardPath === null ? "" : ` with runtime-guard ${shortenPath(runtimeGuardPath)}`}, but no configured daemon runtime path is visible.`
+        };
+    }
+    const samePath = daemonPath === hookPath || daemonPath === runtimeGuardPath;
+    const daemonVersion = daemonInspection?.configuredRuntimePackageVersion ?? null;
+    const hookVersion = hookInspection.packageVersion ?? null;
+    const skew = samePath
+        ? "same_path"
+        : daemonVersion !== null && hookVersion !== null
+            ? daemonVersion === hookVersion
+                ? "split_path_same_version"
+                : "split_path_version_skew"
+            : "split_path_version_unverified";
+    return {
+        boundary: samePath ? "same_surface" : "split_surfaces",
+        skew,
+        daemonPath,
+        hookPath,
+        runtimeGuardPath,
+        daemonPackage,
+        hookPackage,
+        guidance: samePath
+            ? "Daemon and installed hook paths currently collapse to the same file; verify both surfaces before patching anyway."
+            : "Patch the daemon runtime path for background watch/learner fixes. Patch the installed hook/runtime-guard paths for OpenClaw load fixes.",
+        detail: samePath
+            ? `daemon runtime path ${shortenPath(daemonPath)} currently resolves to the same file as the installed OpenClaw hook surface.`
+            : `daemon background watch runs from ${shortenPath(daemonPath)}${daemonPackage === null ? "" : ` (${daemonPackage})`}; OpenClaw loads the installed hook from ${hookPath === null ? "unverified" : shortenPath(hookPath)}${hookPackage === null ? "" : ` (${hookPackage})`}${runtimeGuardPath === null ? "" : ` and runtime-guard ${shortenPath(runtimeGuardPath)}`}.`
+    };
+}
 //# sourceMappingURL=openclaw-hook-truth.js.map

package/dist/src/proof-command.js

@@ -546,7 +546,7 @@ function buildVerdict({ steps, gatewayStatus, pluginInspect, statusSignals, brea
     };
 }
 
-function buildSummary({ options, steps, verdict, gatewayStatusText, pluginInspectText, statusSignals, breadcrumbs, runtimeLoadProofSnapshot, guardLine, feedbackLine, attributionLine, attributionCoverageLine, learningPathLine, coverageSnapshot, hardeningSnapshot }) {
+function buildSummary({ options, steps, verdict, gatewayStatusText, pluginInspectText, statusSignals, breadcrumbs, runtimeLoadProofSnapshot, surfaceLine, surfacesLine, hotfixLine, guardLine, feedbackLine, attributionLine, attributionCoverageLine, learningPathLine, learningFlowLine, learningHealthLine, coverageSnapshot, hardeningSnapshot }) {
     const passed = [];
     const missing = [];
     const warnings = Array.isArray(verdict.warnings) ? verdict.warnings : [];
@@ -602,11 +602,33 @@ function buildSummary({ options, steps, verdict, gatewayStatusText, pluginInspec
         "## Warnings",
         ...(warnings.length === 0 ? ["- none"] : warnings.map((item) => `- ${item}`)),
         "",
+        "## Hotfix Boundary",
+        ...(surfaceLine === null
+            ? ["- hotfix boundary line not reported by detailed status"]
+            : [`- ${surfaceLine}`]),
+        ...(surfacesLine === null
+            ? ["- hotfix paths line not reported by detailed status"]
+            : [`- ${surfacesLine}`]),
+        ...(hotfixLine === null
+            ? ["- hotfix guidance line not reported by detailed status"]
+            : [`- ${hotfixLine}`]),
+        "",
         "## Runtime Guard",
         ...(guardLine === null
             ? ["- runtime guard line not reported by detailed status"]
             : [`- ${guardLine}`]),
         "",
+        "## Learning Flow",
+        ...(learningPathLine === null
+            ? ["- learning path line not reported by detailed status"]
+            : [`- ${learningPathLine}`]),
+        ...(learningFlowLine === null
+            ? ["- learning flow line not reported by detailed status"]
+            : [`- ${learningFlowLine}`]),
+        ...(learningHealthLine === null
+            ? ["- learning health line not reported by detailed status"]
+            : [`- ${learningHealthLine}`]),
+        "",
         "## Learning Attribution",
         ...(feedbackLine === null
             ? ["- feedback line not reported by detailed status"]
@@ -617,9 +639,6 @@ function buildSummary({ options, steps, verdict, gatewayStatusText, pluginInspec
         ...(attributionCoverageLine === null
             ? ["- attribution coverage line not reported by detailed status"]
             : [`- ${attributionCoverageLine}`]),
-        ...(learningPathLine === null
-            ? []
-            : [`- ${learningPathLine}`]),
         "",
         "## Coverage snapshot",
         `- attached profiles: ${coverageSnapshot.attachedProfileCount}`,
@@ -916,11 +935,16 @@ export function captureOperatorProofBundle(options) {
     const gatewayLogPath = extractGatewayLogPath(gatewayStatusCapture.stdout);
     const activationRoot = extractActivationRoot(statusCapture.stdout, options.activationRoot ?? null);
     const statusSignals = extractStatusSignals(statusCapture.stdout);
+    const surfaceLine = extractDetailedStatusLine(statusCapture.stdout, "surface");
+    const surfacesLine = extractDetailedStatusLine(statusCapture.stdout, "surfaces");
+    const hotfixLine = extractDetailedStatusLine(statusCapture.stdout, "hotfix");
     const attachTruthLine = extractDetailedStatusLine(statusCapture.stdout, "attachTruth");
     const attachedSetLine = extractDetailedStatusLine(statusCapture.stdout, "attachedSet");
     const serveLine = extractDetailedStatusLine(statusCapture.stdout, "serve");
     const routeFnLine = extractDetailedStatusLine(statusCapture.stdout, "routeFn");
     const guardLine = extractDetailedStatusLine(statusCapture.stdout, "guard");
+    const learningFlowLine = extractDetailedStatusLine(statusCapture.stdout, "learnFlow");
+    const learningHealthLine = extractDetailedStatusLine(statusCapture.stdout, "health");
     const feedbackLine = extractDetailedStatusLine(statusCapture.stdout, "feedback");
     const attributionLine = extractDetailedStatusLine(statusCapture.stdout, "attribution");
     const attributionCoverageLine = extractDetailedStatusLine(statusCapture.stdout, "attrCover");
@@ -978,7 +1002,12 @@ export function captureOperatorProofBundle(options) {
         },
         runtimeLoadProofPath,
         runtimeLoadProofError: runtimeLoadProofSnapshot.error,
+        surfaceLine,
+        surfacesLine,
+        hotfixLine,
         guardLine,
+        learningFlowLine,
+        learningHealthLine,
         feedbackLine,
         attributionLine,
         attributionCoverageLine,
@@ -994,7 +1023,12 @@ export function captureOperatorProofBundle(options) {
         statusSignals,
         breadcrumbs,
         runtimeLoadProofSnapshot,
+        surfaceLine,
+        surfacesLine,
+        hotfixLine,
         guardLine,
+        learningFlowLine,
+        learningHealthLine,
         feedbackLine,
         attributionLine,
         attributionCoverageLine,
@@ -1015,7 +1049,12 @@ export function captureOperatorProofBundle(options) {
         hardeningSnapshot,
         verdict,
         statusSignals,
+        surfaceLine,
+        surfacesLine,
+        hotfixLine,
         guardLine,
+        learningFlowLine,
+        learningHealthLine,
         feedbackLine,
         attributionLine,
         attributionCoverageLine,

package/dist/src/status-learning-path.js

@@ -7,10 +7,123 @@ function isSeedAwaitingFirstPromotion(status) {
 function normalizeOptionalString(value) {
     return typeof value === "string" && value.trim().length > 0 ? value : null;
 }
+function normalizeCount(value) {
+    return Number.isFinite(value) && value >= 0 ? Math.trunc(value) : 0;
+}
 function formatOptionalFeedbackLatest(tracedLearning) {
     const latestLabel = normalizeOptionalString(tracedLearning?.feedbackSummary?.latestLabel);
     return latestLabel === null ? "" : ` latest=${latestLabel}`;
 }
+function isLearningSurfaceVisible(tracedLearning) {
+    return tracedLearning?.present !== false;
+}
+function hasKnownAttributionCoverage(coverage) {
+    return coverage !== null &&
+        typeof coverage === "object" &&
+        !Array.isArray(coverage) &&
+        (coverage.visible === true ||
+            coverage.gatingVisible === true ||
+            Number.isFinite(coverage.completedWithoutEvaluationCount) ||
+            Number.isFinite(coverage.readyCount) ||
+            Number.isFinite(coverage.delayedCount) ||
+            Number.isFinite(coverage.budgetDeferredCount));
+}
+function readSupervisedTraceCount(tracedLearning) {
+    return normalizeCount(tracedLearning?.feedbackSummary?.supervisedTraceCount ?? tracedLearning?.supervisionCount);
+}
+function hasLoadedLearningSignal(tracedLearning) {
+    return normalizeOptionalString(tracedLearning?.materializedPackId) !== null ||
+        normalizeCount(tracedLearning?.routeTraceCount) > 0 ||
+        readSupervisedTraceCount(tracedLearning) > 0 ||
+        normalizeCount(tracedLearning?.routerUpdateCount) > 0;
+}
+function summarizeOperatorLearningFlow(tracedLearning) {
+    const surfaceVisible = isLearningSurfaceVisible(tracedLearning);
+    return {
+        harvested: surfaceVisible ? normalizeCount(tracedLearning?.teacherArtifactCount) : null,
+        eligible: hasKnownAttributionCoverage(tracedLearning?.attributionCoverage)
+            ? normalizeCount(tracedLearning?.attributionCoverage?.readyCount)
+            : null,
+        loaded: surfaceVisible ? hasLoadedLearningSignal(tracedLearning) : null,
+        pack: surfaceVisible ? normalizeOptionalString(tracedLearning?.materializedPackId) ?? "none" : null,
+        matched: surfaceVisible ? normalizeCount(tracedLearning?.routeTraceCount) : null,
+        supervised: surfaceVisible ? readSupervisedTraceCount(tracedLearning) : null,
+        updated: surfaceVisible ? normalizeCount(tracedLearning?.routerUpdateCount) : null
+    };
+}
+function formatKnownOperatorValue(value) {
+    return value === null ? "unknown" : String(value);
+}
+function summarizeOperatorLearningState(flow) {
+    if (flow.harvested === null &&
+        flow.eligible === null &&
+        flow.loaded === null &&
+        flow.matched === null &&
+        flow.supervised === null &&
+        flow.updated === null) {
+        return {
+            state: "learning-unknown",
+            detail: "learning stage truth is not visible in the current status surface"
+        };
+    }
+    if (flow.harvested > 0 &&
+        flow.eligible !== null &&
+        flow.eligible > 0 &&
+        flow.matched === 0 &&
+        flow.supervised === 0 &&
+        flow.updated === 0) {
+        return {
+            state: "stalled-learning",
+            detail: "harvested artifacts and eligible feedback are visible, but no matched routes, supervision, or router updates are visible"
+        };
+    }
+    if ((flow.matched ?? 0) > 0 || (flow.supervised ?? 0) > 0 || (flow.updated ?? 0) > 0) {
+        return {
+            state: "progress-visible",
+            detail: `matched=${flow.matched ?? 0} supervised=${flow.supervised ?? 0} updated=${flow.updated ?? 0}`
+        };
+    }
+    if (flow.harvested > 0 && flow.eligible === 0) {
+        return {
+            state: "harvested-not-yet-eligible",
+            detail: "teacher artifacts are visible, but no eligible feedback is queued yet"
+        };
+    }
+    if (flow.harvested > 0 && flow.eligible === null) {
+        return {
+            state: "harvested-eligibility-unknown",
+            detail: "teacher artifacts are visible, but eligible feedback truth is not surfaced yet"
+        };
+    }
+    if (flow.harvested === 0 && flow.eligible !== null && flow.eligible > 0) {
+        return {
+            state: "eligible-without-harvest",
+            detail: "eligible feedback is visible without harvested teacher artifacts"
+        };
+    }
+    if (flow.harvested === 0 && flow.eligible === 0) {
+        return {
+            state: "idle-no-eligible-feedback",
+            detail: "no harvested teacher artifacts or eligible feedback are visible"
+        };
+    }
+    return {
+        state: "learning-unknown",
+        detail: "learning stage truth is incomplete"
+    };
+}
+function summarizeOperatorDaemonState(teacher) {
+    if (teacher?.enabled !== true) {
+        return "daemon-disabled";
+    }
+    if (teacher?.healthy === true) {
+        return "healthy-daemon";
+    }
+    if (teacher?.healthy === false) {
+        return "degraded-daemon";
+    }
+    return "daemon-unknown";
+}
 function formatOperatorFeedbackSummary({ tracedLearning }) {
     const routeTraceCount = tracedLearning?.feedbackSummary?.routeTraceCount ?? tracedLearning?.routeTraceCount ?? 0;
     const supervisedTraceCount = tracedLearning?.feedbackSummary?.supervisedTraceCount ?? tracedLearning?.supervisionCount ?? 0;
@@ -78,4 +191,21 @@ export function formatOperatorLearningPathSummary({ status, learningPath, traced
         ...detailParts
     ].join(" ");
 }
+export function formatOperatorLearningFlowSummary({ tracedLearning }) {
+    const flow = summarizeOperatorLearningFlow(tracedLearning);
+    return [
+        `harvested=${formatKnownOperatorValue(flow.harvested)}`,
+        `eligible=${formatKnownOperatorValue(flow.eligible)}`,
+        `loaded=${flow.loaded === null ? "unknown" : flow.loaded ? "yes" : "no"}`,
+        `pack=${flow.pack ?? "unknown"}`,
+        `matched=${formatKnownOperatorValue(flow.matched)}`,
+        `supervised=${formatKnownOperatorValue(flow.supervised)}`,
+        `updated=${formatKnownOperatorValue(flow.updated)}`
+    ].join(" ");
+}
+export function formatOperatorLearningHealthSummary({ tracedLearning, teacher }) {
+    const flow = summarizeOperatorLearningFlow(tracedLearning);
+    const learning = summarizeOperatorLearningState(flow);
+    return `daemon=${summarizeOperatorDaemonState(teacher)} learning=${learning.state} detail=${learning.detail}`;
+}
 export { formatOperatorAttributionCoverageSummary, formatOperatorFeedbackSummary, formatOperatorLearningAttributionSummary };

package/dist/src/teacher-labeler.d.ts

@@ -1,5 +1,5 @@
 import { type NormalizedEventExportV1, type TeacherSupervisionArtifactV1 } from "@openclawbrain/contracts";
-import type { LearningSpineServeRouteDecisionLogEntryV1 } from "@openclawbrain/pack-format";
+import type { LearningSpineServeRouteDecisionLogEntryV1 } from "./local-learner.js";
 export interface TeacherLabelerRunInputV1 {
     normalizedEventExport: NormalizedEventExportV1;
     observedAt: string;

package/dist/src/teacher-labeler.js

@@ -141,11 +141,14 @@ function buildPrompt(candidates, config) {
         payload
     ].join("\n");
 }
+function isTeacherLabelerCandidateInteraction(interaction) {
+    return interaction.kind === "memory_compiled" || interaction.kind === "message_delivered";
+}
 function collectCandidates(input, config) {
     const decisions = [...(input.serveTimeDecisions ?? [])].sort((left, right) => Date.parse(right.recordedAt) - Date.parse(left.recordedAt));
     const matchServeTimeDecision = createServeTimeDecisionMatcher(decisions);
     return input.normalizedEventExport.interactionEvents
-        .filter((interaction) => interaction.kind === "memory_compiled")
+        .filter((interaction) => isTeacherLabelerCandidateInteraction(interaction))
         .sort((left, right) => Date.parse(right.createdAt) - Date.parse(left.createdAt))
         .map((interaction) => {
         const decision = matchServeTimeDecision(interaction);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclawbrain/cli",
-  "version": "0.4.26",
+  "version": "0.4.28",
   "description": "OpenClawBrain operator CLI package with install/status helpers, daemon controls, and import/export tooling.",
   "type": "module",
   "main": "./dist/src/index.js",