@openclawbrain/cli 0.4.3 → 0.4.5

package/README.md

@@ -1,29 +1,29 @@
 # @openclawbrain/cli
 
-`@openclawbrain/cli@0.4.3` is the published operator CLI package for OpenClawBrain.
+`@openclawbrain/cli@0.4.5` is the published operator CLI package for OpenClawBrain.
 
 Primary public flow:
 
 ```bash
 openclaw plugins install @openclawbrain/openclaw@0.4.0
-npx @openclawbrain/cli@0.4.3 install --openclaw-home ~/.openclaw
+npx @openclawbrain/cli@0.4.5 install --openclaw-home ~/.openclaw
 openclaw gateway restart
-npx @openclawbrain/cli@0.4.3 status --openclaw-home ~/.openclaw --detailed
+npx @openclawbrain/cli@0.4.5 status --openclaw-home ~/.openclaw --detailed
 ```
 
-Patch note for `0.4.3`: the CLI now reports active-pack numeric embeddings more truthfully across alternate vector shapes, and the repo-side serve-time decision matcher is more tolerant of event-id and timestamp drift when harvesting supervision candidates.
+Patch note for `0.4.4`: the CLI now normalizes `plugins.allow` / `plugins.entries.openclawbrain` correctly on reinstall and reports the canonical `openclawbrain` install identity in status output.
 
-Current caveat: some hosts still warn about a plugin id mismatch because the plugin manifest uses `openclawbrain` while the package/entry hint uses `openclaw`. The install still works; treat that warning as currently cosmetic.
+Host release note: patched OpenClaw host builds no longer emit the old `openclaw` vs `openclawbrain` mismatch warning. Older host builds may still show that warning until the host-side alias fix is released there.
 
 This package carries the `openclawbrain` CLI, daemon controls, import/export helpers, and install/status/operator management code. `@openclawbrain/openclaw` is the plugin/runtime payload.
 
 ## Commands
 
 ```bash
-npx @openclawbrain/cli@0.4.3 install --openclaw-home ~/.openclaw
-npx @openclawbrain/cli@0.4.3 status --openclaw-home ~/.openclaw --detailed
-npx @openclawbrain/cli@0.4.3 rollback --activation-root /var/openclawbrain/activation --dry-run
-npx @openclawbrain/cli@0.4.3 daemon status --activation-root /var/openclawbrain/activation
+npx @openclawbrain/cli@0.4.5 install --openclaw-home ~/.openclaw
+npx @openclawbrain/cli@0.4.5 status --openclaw-home ~/.openclaw --detailed
+npx @openclawbrain/cli@0.4.5 rollback --activation-root /var/openclawbrain/activation --dry-run
+npx @openclawbrain/cli@0.4.5 daemon status --activation-root /var/openclawbrain/activation
 ```
 
 If the CLI is already on your `PATH`, `openclawbrain ...` is the same command surface. The docs lead with `npx` because that is the clean-host public-registry lane that already passed on `redogfood`.

package/dist/src/cli.d.ts

@@ -139,6 +139,7 @@ export interface WatchCommandRuntimeV1 {
     teacherLoop: ReturnType<typeof createAsyncTeacherLiveLoop>;
     localSessionTail: ReturnType<typeof createOpenClawLocalSessionTail>;
     embedder: TextEmbedder | null;
+    consumeBaselinePersisted: () => boolean;
 }
 export interface CreateWatchCommandRuntimeInputV1 {
     activationRoot: string;

package/dist/src/cli.js

@@ -9,18 +9,18 @@ import { DEFAULT_OLLAMA_EMBEDDING_MODEL, createOllamaEmbedder } from "@openclawb
 import { ensureManagedLearnerServiceForActivationRoot, inspectManagedLearnerService, removeManagedLearnerServiceForActivationRoot, parseDaemonArgs, runDaemonCommand } from "./daemon.js";
 import { exportBrain, importBrain } from "./import-export.js";
 import { buildNormalizedEventExport } from "@openclawbrain/contracts";
-import { buildTeacherSupervisionArtifactsFromNormalizedEventExport, createAlwaysOnLearningRuntimeState, describeAlwaysOnLearningRuntimeState, drainAlwaysOnLearningRuntime, loadOrInitBaseline, reindexCandidatePackBuildResultWithEmbedder, materializeAlwaysOnLearningCandidatePack, persistBaseline } from "@openclawbrain/learner";
+import { buildTeacherSupervisionArtifactsFromNormalizedEventExport, createAlwaysOnLearningRuntimeState, describeAlwaysOnLearningRuntimeState, drainAlwaysOnLearningRuntime, loadOrInitBaseline, reindexCandidatePackBuildResultWithEmbedder, materializeAlwaysOnLearningCandidatePack, persistBaseline } from "./local-learner.js";
 import { inspectActivationState, loadPackFromActivation, promoteCandidatePack, readLearningSpineLogEntries, 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 { describeOpenClawBrainInstallIdentity, describeOpenClawBrainInstallLayout, findInstalledOpenClawBrainPlugin, getOpenClawBrainKnownPluginIds, pinInstalledOpenClawBrainPluginActivationRoot, resolveOpenClawBrainInstallTarget } from "./openclaw-plugin-install.js";
+import { describeOpenClawBrainInstallIdentity, describeOpenClawBrainInstallLayout, findInstalledOpenClawBrainPlugin, getOpenClawBrainKnownPluginIds, normalizeOpenClawBrainPluginsConfig, pinInstalledOpenClawBrainPluginActivationRoot, resolveOpenClawBrainInstallTarget } from "./openclaw-plugin-install.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, writeScannedEventExportBundle } from "./index.js";
 import { appendLearningUpdateLogs } from "./learning-spine.js";
 import { buildPassiveLearningSessionExportFromOpenClawSessionStore } from "./local-session-passive-learning.js";
 import { summarizePackVectorEmbeddingState } from "./embedding-status.js";
-import { buildTracedLearningStatusSurface, loadBrainStoreTracedLearningBridge, mergeTracedLearningBridgePayload, persistBrainStoreTracedLearningBridge, writeTracedLearningBridge } from "./traced-learning-bridge.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";
 const OPENCLAWBRAIN_EMBEDDER_BASE_URL_ENV = "OPENCLAWBRAIN_EMBEDDER_BASE_URL";
@@ -3581,46 +3581,42 @@ function readOpenClawJsonConfig(openclawHome) {
 function ensureOpenClawBrainPluginConfig(openclawHome) {
     const { path: openclawJsonPath, config } = readOpenClawJsonConfig(openclawHome);
     const selectedInstall = findInstalledOpenClawBrainPlugin(openclawHome).selectedInstall;
-    const knownPluginIds = selectedInstall === null
-        ? ["openclawbrain", "openclaw"]
-        : getOpenClawBrainKnownPluginIds(selectedInstall);
     const plugins = readJsonObjectRecord(config.plugins);
     if (plugins === null) {
         return {
             path: openclawJsonPath,
             changed: false,
-            detail: `Left ${shortenPath(openclawJsonPath)} unchanged because plugins.allow is not configured`
+            detail: `Left ${shortenPath(openclawJsonPath)} unchanged because plugins config is not configured`
         };
     }
-    if (!Object.prototype.hasOwnProperty.call(plugins, "allow")) {
-        return {
-            path: openclawJsonPath,
-            changed: false,
-            detail: `Left ${shortenPath(openclawJsonPath)} unchanged because plugins.allow is not configured`
-        };
-    }
-    if (!Array.isArray(plugins.allow)) {
-        return {
-            path: openclawJsonPath,
-            changed: false,
-            detail: `Left ${shortenPath(openclawJsonPath)} unchanged because plugins.allow is not an array`
-        };
-    }
-    const missingPluginIds = knownPluginIds.filter((pluginId) => !plugins.allow.includes(pluginId));
-    if (missingPluginIds.length === 0) {
+    const normalizedPlugins = normalizeOpenClawBrainPluginsConfig(plugins, selectedInstall);
+    if (!normalizedPlugins.changed) {
+        const details = [];
+        if (!Object.prototype.hasOwnProperty.call(plugins, "allow")) {
+            details.push("plugins.allow is not configured");
+        }
+        else if (!Array.isArray(plugins.allow)) {
+            details.push("plugins.allow is not an array");
+        }
+        else {
+            details.push(`plugins.allow already includes ${normalizedPlugins.allowedPluginIds.join(", ")}`);
+        }
+        const entries = readJsonObjectRecord(plugins.entries);
+        if (entries !== null && Object.prototype.hasOwnProperty.call(entries, normalizedPlugins.canonicalEntryId)) {
+            details.push(`plugins.entries already uses ${normalizedPlugins.canonicalEntryId}`);
+        }
         return {
             path: openclawJsonPath,
             changed: false,
-            detail: `Verified ${shortenPath(openclawJsonPath)} plugins.allow already includes ${knownPluginIds.join(", ")}`
+            detail: `Verified ${shortenPath(openclawJsonPath)} ${details.join("; ")}`
         };
     }
-    plugins.allow = [...plugins.allow, ...missingPluginIds];
-    config.plugins = plugins;
+    config.plugins = normalizedPlugins.pluginsConfig;
     writeFileSync(openclawJsonPath, `${JSON.stringify(config, null, 2)}\n`, "utf8");
     return {
         path: openclawJsonPath,
         changed: true,
-        detail: `Repaired ${shortenPath(openclawJsonPath)} plugins.allow by adding ${missingPluginIds.join(", ")}`
+        detail: `Repaired ${shortenPath(openclawJsonPath)} by ${normalizedPlugins.changes.join("; ")}`
     };
 }
 function scrubOpenClawBrainPluginConfig(openclawHome) {
@@ -3979,6 +3975,37 @@ function resolveServeTimeLearningRuntimeInput(activationRoot) {
         fallbackReason
     };
 }
+function resolveActivationInspectionPackId(inspection, slot) {
+    return inspection?.[slot]?.packId ?? inspection?.pointers?.[slot]?.packId ?? null;
+}
+function resolveWatchTeacherArtifactCount(snapshot) {
+    if (typeof snapshot?.teacher?.artifactCount === "number") {
+        return snapshot.teacher.artifactCount;
+    }
+    if (typeof snapshot?.diagnostics?.emittedArtifactCount === "number") {
+        return snapshot.diagnostics.emittedArtifactCount;
+    }
+    return 0;
+}
+function persistWatchTracedLearningBridgeSurface(input) {
+    const lastMaterialization = input.snapshot?.learner?.lastMaterialization ?? null;
+    const materializedPackId = lastMaterialization?.candidate?.summary?.packId ?? null;
+    return persistTracedLearningBridgeState(input.activationRoot, buildTracedLearningBridgePayloadFromRuntime({
+        updatedAt: input.updatedAt,
+        lastMaterialization,
+        teacherArtifactCount: resolveWatchTeacherArtifactCount(input.snapshot),
+        serveTimeLearning: resolveServeTimeLearningRuntimeInput(input.activationRoot),
+        materializedPackId,
+        promoted: materializedPackId !== null &&
+            resolveActivationInspectionPackId(input.inspection, "active") === materializedPackId,
+        baselinePersisted: input.baselinePersisted,
+        source: {
+            command: "watch",
+            scanRoot: input.scanRoot,
+            teacherSnapshotPath: input.teacherSnapshotPath
+        }
+    }));
+}
 function runLearnCommand(parsed) {
     const learnStatePath = path.join(parsed.activationRoot, "learn-cli-state.json");
     const teacherSnapshotPath = resolveAsyncTeacherLiveLoopSnapshotPath(parsed.activationRoot);
@@ -4216,9 +4243,6 @@ function runLearnCommand(parsed) {
     const lastMaterialization = learnerResult.materializations.at(-1) ?? null;
     const plan = describeAlwaysOnLearningRuntimeState(learnerResult.state, lastMaterialization);
     const learningPath = summarizeLearningPathFromMaterialization(lastMaterialization);
-    const supervisionCount = lastMaterialization?.candidate.summary.learnedRouter.supervisionCount ?? 0;
-    const routerUpdateCount = lastMaterialization?.candidate.summary.learnedRouter.updateCount ?? 0;
-    const routerNoOpReason = lastMaterialization?.candidate.summary.learnedRouter.noOpReason ?? null;
     const graphEvolution = lastMaterialization?.candidate.payloads.graph.evolution;
     const graphSummary = graphEvolution === undefined
         ? null
@@ -4229,18 +4253,28 @@ function runLearnCommand(parsed) {
     const connectSummary = graphSummary?.connectDiagnostics === null || graphSummary?.connectDiagnostics === undefined
         ? ""
         : ` connect candidates=${graphSummary.connectDiagnostics.candidatePairCount} applied=${graphSummary.connectDiagnostics.appliedPairCount} edges=${graphSummary.connectDiagnostics.createdEdgeCount}.`;
-    const routingBuild = lastMaterialization?.candidate.routingBuild ?? {
-        learnedRoutingPath: serveTimeLearning.pgVersion === "v2" ? "policy_gradient_v2" : "policy_gradient_v1",
-        pgVersionRequested: serveTimeLearning.pgVersion,
-        pgVersionUsed: serveTimeLearning.pgVersion,
-        decisionLogCount: serveTimeLearning.decisionLogCount,
-        fallbackReason: serveTimeLearning.pgVersion === "v1" ? serveTimeLearning.fallbackReason ?? "no_serve_time_decisions" : null,
-        updatedBaseline: null
-    };
+    const tracedLearningPreview = buildTracedLearningBridgePayloadFromRuntime({
+        updatedAt: now,
+        lastMaterialization,
+        teacherArtifactCount: teacherArtifacts.length,
+        serveTimeLearning,
+        source: {
+            command: "learn",
+            exportDigest: learningExport.provenance.exportDigest,
+            teacherSnapshotPath
+        }
+    });
+    const supervisionCount = tracedLearningPreview.supervisionCount;
+    const routerUpdateCount = tracedLearningPreview.routerUpdateCount;
+    const routerNoOpReason = tracedLearningPreview.routerNoOpReason;
     const learnPathReport = {
-        ...routingBuild,
-        fallbackReason: routingBuild.fallbackReason ??
-            (routingBuild.pgVersionUsed === "v1" ? serveTimeLearning.fallbackReason ?? "no_serve_time_decisions" : null)
+        learnedRoutingPath: lastMaterialization?.candidate.routingBuild?.learnedRoutingPath ??
+            (serveTimeLearning.pgVersion === "v2" ? "policy_gradient_v2" : "policy_gradient_v1"),
+        pgVersionRequested: tracedLearningPreview.pgVersionRequested,
+        pgVersionUsed: tracedLearningPreview.pgVersionUsed,
+        decisionLogCount: tracedLearningPreview.decisionLogCount,
+        fallbackReason: tracedLearningPreview.fallbackReason,
+        updatedBaseline: lastMaterialization?.candidate.routingBuild?.updatedBaseline ?? null
     };
     let promoted = false;
     let materializedPackId = null;
@@ -4269,6 +4303,20 @@ function runLearnCommand(parsed) {
         materializedPackId = candidateDescriptor.manifest.packId;
         promoted = true;
     }
+    const tracedLearningPayload = buildTracedLearningBridgePayloadFromRuntime({
+        updatedAt: now,
+        lastMaterialization,
+        teacherArtifactCount: teacherArtifacts.length,
+        serveTimeLearning,
+        materializedPackId,
+        promoted,
+        baselinePersisted,
+        source: {
+            command: "learn",
+            exportDigest: learningExport.provenance.exportDigest,
+            teacherSnapshotPath
+        }
+    });
     persistLearnCliState(learnerResult.state, now);
     writeJsonFile(teacherSnapshotPath, {
         runtimeOwner: "openclaw",
@@ -4315,31 +4363,10 @@ function runLearnCommand(parsed) {
             lastAppliedMaterializationJobId: lastMaterialization?.jobId ?? null
         }
     });
-    const tracedLearningBridge = mergeTracedLearningBridgePayload({
-        updatedAt: now,
-        routeTraceCount: lastMaterialization?.candidate.summary.learnedRouter.routeTraceCount ?? serveTimeLearning.decisionLogCount,
-        supervisionCount,
-        routerUpdateCount,
-        teacherArtifactCount: teacherArtifacts.length,
-        pgVersionRequested: learnPathReport.pgVersionRequested,
-        pgVersionUsed: learnPathReport.pgVersionUsed,
-        decisionLogCount: learnPathReport.decisionLogCount,
-        fallbackReason: learnPathReport.fallbackReason,
-        routerNoOpReason,
-        materializedPackId,
-        promoted,
-        baselinePersisted,
-        source: {
-            command: "learn",
-            exportDigest: learningExport.provenance.exportDigest,
-            teacherSnapshotPath
-        }
-    }, loadBrainStoreTracedLearningBridge());
+    const tracedLearningBridge = persistTracedLearningBridgeState(activationRoot, tracedLearningPayload);
     const surfacedSupervisionCount = tracedLearningBridge.supervisionCount;
     const surfacedRouterUpdateCount = tracedLearningBridge.routerUpdateCount;
     const surfacedRouterNoOpReason = tracedLearningBridge.routerNoOpReason;
-    persistBrainStoreTracedLearningBridge(tracedLearningBridge);
-    writeTracedLearningBridge(activationRoot, tracedLearningBridge);
     const summaryMessage = materializedPackId === null
         ? `Scanned ${totalSessions} sessions, ${totalEvents} new events, no candidate materialized, no promotion.`
         : `Scanned ${totalSessions} sessions, ${totalEvents} new events, materialized ${materializedPackId}, promoted.${connectSummary}`;
@@ -4971,6 +4998,7 @@ export async function createWatchCommandRuntime(input) {
     const restoredTeacherState = loadWatchTeacherSnapshotState(teacherSnapshotPath);
     const log = input.log ?? watchLog;
     const startupWarnings = [];
+    let baselinePersisted = false;
     mkdirSync(scanRoot, { recursive: true });
     mkdirSync(resolveWatchStateRoot(activationRoot), { recursive: true });
     log(`Watch starting — activation: ${shortenPath(activationRoot)}`);
@@ -5024,6 +5052,7 @@ export async function createWatchCommandRuntime(input) {
         persistUpdatedBaseline: (state) => {
             try {
                 persistBaseline(activationRoot, state);
+                baselinePersisted = true;
             }
             catch (error) {
                 log(`Baseline persist failed: ${formatWatchError(error)}`);
@@ -5143,6 +5172,17 @@ export async function createWatchCommandRuntime(input) {
         log(replayPromotion.logLine);
         bootstrapSnapshot = teacherLoop.snapshot();
     }
+    const bootstrapInspection = inspectActivationState(activationRoot, bootstrapObservedAt);
+    persistWatchTracedLearningBridgeSurface({
+        activationRoot,
+        updatedAt: bootstrapObservedAt,
+        snapshot: bootstrapSnapshot,
+        inspection: bootstrapInspection,
+        scanRoot,
+        teacherSnapshotPath,
+        baselinePersisted
+    });
+    baselinePersisted = false;
     const bootstrapCursor = localSessionTail.snapshot();
     persistWatchTeacherSnapshot(teacherSnapshotPath, {
         lastRunAt: bootstrapObservedAt,
@@ -5192,7 +5232,12 @@ export async function createWatchCommandRuntime(input) {
         scanner,
         teacherLoop,
         localSessionTail,
-        embedder: resolvedEmbedder.embedder
+        embedder: resolvedEmbedder.embedder,
+        consumeBaselinePersisted: () => {
+            const persisted = baselinePersisted;
+            baselinePersisted = false;
+            return persisted;
+        }
     };
 }
 export async function runWatchCommandPass(runtime, options = {}) {
@@ -5271,6 +5316,17 @@ export async function runWatchCommandPass(runtime, options = {}) {
         }
     }
     const afterInspection = inspectActivationState(runtime.activationRoot, observedAt);
+    persistWatchTracedLearningBridgeSurface({
+        activationRoot: runtime.activationRoot,
+        updatedAt: observedAt,
+        snapshot,
+        inspection: afterInspection,
+        scanRoot: runtime.scanRoot,
+        teacherSnapshotPath: runtime.teacherSnapshotPath,
+        baselinePersisted: typeof runtime.consumeBaselinePersisted === "function"
+            ? runtime.consumeBaselinePersisted()
+            : false
+    });
     const lastObservedDelta = buildWatchLastObservedDelta({
         observedAt,
         localPoll,

package/dist/src/index.d.ts

@@ -1,7 +1,7 @@
 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 "@openclawbrain/learner";
+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";
 export { clearOpenClawProfileRuntimeLoadProof, listOpenClawProfileRuntimeLoadProofs, recordOpenClawProfileRuntimeLoadProof, resolveAttachmentRuntimeLoadProofsPath, type OpenClawProfileRuntimeLoadProofRecordV1, type OpenClawProfileRuntimeLoadProofSetV1, type OpenClawProfileRuntimeLoadProofsV1 } from "./attachment-truth.js";
 import { type AsyncTeacherLabelerConfigV1 } from "./teacher-labeler.js";

package/dist/src/index.js

@@ -5,7 +5,7 @@ import process from "node:process";
 import { compileRuntimeFromActivation } from "@openclawbrain/compiler";
 import { CONTRACT_IDS, buildEventSemanticSurface, buildNormalizedEventExport, canonicalJson, checksumJsonPayload, createFeedbackEvent, createInteractionEvent, sortNormalizedEvents, validateKernelSurface, validateNormalizedEventExport } from "@openclawbrain/contracts";
 import { classifyFeedbackSignalContent, describeNormalizedEventExportObservability } from "@openclawbrain/event-export";
-import { DEFAULT_TEACHER_SUPERVISION_STALE_AFTER_MS, advanceAlwaysOnLearningRuntime, buildTeacherSupervisionArtifactsFromNormalizedEventExport, createAlwaysOnLearningRuntimeState, describeAlwaysOnLearningRuntimeState, materializeAlwaysOnLearningCandidatePack, materializeCandidatePackFromNormalizedEventExport } from "@openclawbrain/learner";
+import { DEFAULT_TEACHER_SUPERVISION_STALE_AFTER_MS, advanceAlwaysOnLearningRuntime, buildTeacherSupervisionArtifactsFromNormalizedEventExport, createAlwaysOnLearningRuntimeState, describeAlwaysOnLearningRuntimeState, materializeAlwaysOnLearningCandidatePack, materializeCandidatePackFromNormalizedEventExport } from "./local-learner.js";
 import { LEARNING_SPINE_LOG_LAYOUT, activatePack, describeActivationObservability, describeActivationTarget, describePackCompileTarget, inspectActivationState, loadPackFromActivation, promoteCandidatePack, readLearningSpineLogEntries, rollbackActivePack, stageCandidatePack } from "@openclawbrain/pack-format";
 import { inspectOpenClawBrainHookStatus, summarizeOpenClawBrainHookLoad } from "./openclaw-hook-truth.js";
 import { appendLearningUpdateLogs, appendServeTimeRouteDecisionLog } from "./learning-spine.js";

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

@@ -1,4 +1,4 @@
-import { type AlwaysOnLearningMaterializationJobV1 } from "@openclawbrain/learner";
+import { type AlwaysOnLearningMaterializationJobV1 } from "./local-learner.js";
 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";
 type CompileFailureLike = {

package/dist/src/learning-spine.js

@@ -1,6 +1,6 @@
 import path from "node:path";
 import { rankContextBlocks } from "@openclawbrain/compiler";
-import { describeSparseFeedbackEventDispositions } from "@openclawbrain/learner";
+import { describeSparseFeedbackEventDispositions } from "./local-learner.js";
 import { CONTRACT_IDS } from "@openclawbrain/contracts";
 import { appendLearningSpineLogEntry, buildLearningSpineLogId, loadActivationPointers, loadPack, loadPackFromActivation, readLearningSpineLogEntries } from "@openclawbrain/pack-format";
 function noteValue(notes, prefix) {