@openclawbrain/cli 0.4.25 → 0.4.27

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/dist/src/traced-learning-bridge.js

@@ -258,6 +258,169 @@ function buildDerivedAttributionCoverage(db) {
             : `completed_without_evaluation=${completedWithoutEvaluationCount}; ready=${readyCount}, delayed=${delayedCount}, budget_deferred=${budgetDeferredCount}`
     };
 }
+function loadJsonFile(pathname) {
+    if (!existsSync(pathname)) {
+        return null;
+    }
+    try {
+        return JSON.parse(readFileSync(pathname, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function resolveActivePackPaths(activationRoot) {
+    const pointers = toRecord(loadJsonFile(path.join(path.resolve(activationRoot), "activation-pointers.json")));
+    const active = toRecord(pointers?.active);
+    const packRootDir = normalizeOptionalString(active?.packRootDir)
+        ?? (normalizeOptionalString(active?.packId) === null
+            ? null
+            : path.join(path.resolve(activationRoot), "packs", String(active.packId)));
+    const manifestPath = normalizeOptionalString(active?.manifestPath)
+        ?? (packRootDir === null ? null : path.join(packRootDir, "manifest.json"));
+    return {
+        packRootDir,
+        manifestPath
+    };
+}
+function buildActivePackFeedbackSummary(activationRoot) {
+    const active = resolveActivePackPaths(activationRoot);
+    if (active.packRootDir === null || active.manifestPath === null) {
+        return null;
+    }
+    const manifest = toRecord(loadJsonFile(active.manifestPath));
+    const runtimeAssets = toRecord(manifest?.runtimeAssets);
+    const router = toRecord(runtimeAssets?.router);
+    const routerArtifactPath = normalizeOptionalString(router?.artifactPath);
+    if (routerArtifactPath === null) {
+        return null;
+    }
+    const routerPath = path.isAbsolute(routerArtifactPath)
+        ? routerArtifactPath
+        : path.join(active.packRootDir, routerArtifactPath);
+    const routerArtifact = toRecord(loadJsonFile(routerPath));
+    const traces = Array.isArray(routerArtifact?.traces) ? routerArtifact.traces : [];
+    const verdictCounts = {
+        helpfulCount: 0,
+        irrelevantCount: 0,
+        harmfulCount: 0
+    };
+    for (const trace of traces) {
+        const traceRecord = toRecord(trace);
+        if (normalizeOptionalString(traceRecord?.supervisionKind) === "route_trace") {
+            continue;
+        }
+        const verdict = classifyContextFeedbackVerdict(Number(traceRecord?.reward ?? 0));
+        if (verdict === "helpful") {
+            verdictCounts.helpfulCount += 1;
+        }
+        else if (verdict === "harmful") {
+            verdictCounts.harmfulCount += 1;
+        }
+        else {
+            verdictCounts.irrelevantCount += 1;
+        }
+    }
+    const routeTraceCount = normalizeCount(routerArtifact?.training?.routeTraceCount) || traces.length;
+    const supervisedTraceCount = verdictCounts.helpfulCount + verdictCounts.irrelevantCount + verdictCounts.harmfulCount;
+    if (routeTraceCount === 0 && supervisedTraceCount === 0) {
+        return null;
+    }
+    return {
+        visible: true,
+        ...verdictCounts,
+        supervisedTraceCount,
+        routeTraceCount,
+        latestAgentIdentity: null,
+        latestLabel: null,
+        detail: routeTraceCount === 0
+            ? "no active-pack traced routes are visible"
+            : `${verdictCounts.helpfulCount} helpful, ${verdictCounts.irrelevantCount} irrelevant, ${verdictCounts.harmfulCount} harmful; ${supervisedTraceCount}/${routeTraceCount} active-pack traced routes are supervised`
+    };
+}
+function readIntegerNote(notes, prefix) {
+    if (!Array.isArray(notes)) {
+        return null;
+    }
+    const entry = notes.find((candidate) => typeof candidate === "string" && candidate.startsWith(prefix));
+    if (typeof entry !== "string") {
+        return null;
+    }
+    const parsed = Number.parseInt(entry.slice(prefix.length), 10);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function buildWatchSnapshotAttributionCoverage(activationRoot) {
+    const snapshot = toRecord(loadJsonFile(path.join(path.resolve(activationRoot), "watch", "teacher-snapshot.json")));
+    const notes = Array.isArray(snapshot?.notes)
+        ? snapshot.notes
+        : Array.isArray(snapshot?.snapshot?.diagnostics?.notes)
+            ? snapshot.snapshot.diagnostics.notes
+            : Array.isArray(snapshot?.diagnostics?.notes)
+                ? snapshot.diagnostics.notes
+                : [];
+    const readyCount = readIntegerNote(notes, "teacher_feedback_eligible=");
+    const delayedCount = readIntegerNote(notes, "teacher_feedback_delayed=");
+    const budgetDeferredCount = readIntegerNote(notes, "teacher_feedback_budgeted_out=");
+    const budgetPerTick = readIntegerNote(notes, "teacher_budget=");
+    const delayMs = readIntegerNote(notes, "teacher_delay_ms=");
+    if (readyCount === null && delayedCount === null && budgetDeferredCount === null && budgetPerTick === null && delayMs === null) {
+        return null;
+    }
+    return {
+        visible: true,
+        gatingVisible: budgetPerTick !== null || delayMs !== null,
+        completedWithoutEvaluationCount: 0,
+        readyCount: normalizeCount(readyCount),
+        delayedCount: normalizeCount(delayedCount),
+        budgetDeferredCount: normalizeCount(budgetDeferredCount),
+        detail: `watch sparse-feedback queue: completed_without_evaluation=0, ready=${normalizeCount(readyCount)}, delayed=${normalizeCount(delayedCount)}, budget_deferred=${normalizeCount(budgetDeferredCount)}`
+    };
+}
+function shouldPreferActivationFeedbackSummary(current, fallback) {
+    if (fallback === null) {
+        return false;
+    }
+    if (current.visible !== true) {
+        return true;
+    }
+    return normalizeCount(current.supervisedTraceCount) === 0 && normalizeCount(fallback.supervisedTraceCount) > 0;
+}
+function shouldPreferWatchAttributionCoverage(current, fallback) {
+    if (fallback === null) {
+        return false;
+    }
+    if (current.visible !== true || current.gatingVisible !== true) {
+        return normalizeCount(fallback.readyCount) > 0
+            || normalizeCount(fallback.delayedCount) > 0
+            || normalizeCount(fallback.budgetDeferredCount) > 0;
+    }
+    const currentKnown = normalizeCount(current.completedWithoutEvaluationCount)
+        + normalizeCount(current.readyCount)
+        + normalizeCount(current.delayedCount)
+        + normalizeCount(current.budgetDeferredCount);
+    const fallbackKnown = normalizeCount(fallback.completedWithoutEvaluationCount)
+        + normalizeCount(fallback.readyCount)
+        + normalizeCount(fallback.delayedCount)
+        + normalizeCount(fallback.budgetDeferredCount);
+    return currentKnown === 0 && fallbackKnown > 0;
+}
+function enrichBridgeWithActivationTruth(activationRoot, bridge) {
+    const feedbackSummary = buildActivePackFeedbackSummary(activationRoot);
+    const attributionCoverage = buildWatchSnapshotAttributionCoverage(activationRoot);
+    if (!shouldPreferActivationFeedbackSummary(bridge.feedbackSummary, feedbackSummary)
+        && !shouldPreferWatchAttributionCoverage(bridge.attributionCoverage, attributionCoverage)) {
+        return bridge;
+    }
+    return normalizeBridgePayload({
+        ...bridge,
+        feedbackSummary: shouldPreferActivationFeedbackSummary(bridge.feedbackSummary, feedbackSummary)
+            ? feedbackSummary
+            : bridge.feedbackSummary,
+        attributionCoverage: shouldPreferWatchAttributionCoverage(bridge.attributionCoverage, attributionCoverage)
+            ? attributionCoverage
+            : bridge.attributionCoverage
+    });
+}
 function normalizeLastInterruptionSummary(value) {
     if (value === null || typeof value !== "object" || Array.isArray(value)) {
         return null;
@@ -995,12 +1158,12 @@ export function buildTracedLearningStatusSurface(activationRoot, options = {}) {
     const persisted = loadBrainStoreTracedLearningBridge(options);
     const runtime = loadTracedLearningBridge(activationRoot);
     if (persisted.bridge !== null) {
-        return buildStatusSurface(persisted.path, mergeCanonicalStatusBridge(persisted.bridge, runtime), {
+        return buildStatusSurface(persisted.path, enrichBridgeWithActivationTruth(activationRoot, mergeCanonicalStatusBridge(persisted.bridge, runtime)), {
             runtimeState: describeBridgeRuntimeState(runtime)
         });
     }
     if (runtime.bridge !== null) {
-        return buildStatusSurface(runtime.path, runtime.bridge);
+        return buildStatusSurface(runtime.path, enrichBridgeWithActivationTruth(activationRoot, runtime.bridge));
     }
     if (persisted.error !== null) {
         return defaultSurface(persisted.path, "brain_store_unreadable", persisted.error);

package/package.json

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