@openclawbrain/cli 0.4.25 → 0.4.26

package/dist/src/cli.js

@@ -17,7 +17,7 @@ import { inspectOpenClawBrainHookStatus, inspectOpenClawBrainPluginAllowlist } f
 import { describeOpenClawBrainInstallIdentity, describeOpenClawBrainInstallLayout, findInstalledOpenClawBrainPlugin, getOpenClawBrainKnownPluginIds, normalizeOpenClawBrainPluginsConfig, pinInstalledOpenClawBrainPluginActivationRoot, resolveOpenClawBrainInstallTarget } from "./openclaw-plugin-install.js";
 import { buildOpenClawBrainConvergeRestartPlan, classifyOpenClawBrainConvergeVerification, describeOpenClawBrainConvergeChangeReasons, diffOpenClawBrainConvergeRuntimeFingerprint, finalizeOpenClawBrainConvergeResult, planOpenClawBrainConvergePluginAction, shouldReplaceOpenClawBrainInstallBeforeConverge } from "./install-converge.js";
 import { loadAttachmentPolicyDeclaration, resolveEffectiveAttachmentPolicyTruth, writeAttachmentPolicyDeclaration } from "./attachment-policy-truth.js";
-import { DEFAULT_WATCH_POLL_INTERVAL_SECONDS, buildNormalizedEventExportFromScannedEvents, bootstrapRuntimeAttach, buildOperatorSurfaceReport, clearOpenClawProfileRuntimeLoadProof, compileRuntimeContext, createAsyncTeacherLiveLoop, createOpenClawLocalSessionTail, createRuntimeEventExportScanner, describeCurrentProfileBrainStatus, formatOperatorRollbackReport, listOpenClawProfileRuntimeLoadProofs, loadRuntimeEventExportBundle, loadWatchTeacherSnapshotState, persistWatchTeacherSnapshot, rollbackRuntimeAttach, resolveAttachmentRuntimeLoadProofsPath, resolveOperatorTeacherSnapshotPath, resolveAsyncTeacherLiveLoopSnapshotPath, resolveWatchSessionTailCursorPath, resolveWatchStateRoot, resolveWatchTeacherSnapshotPath, scanLiveEventExport, scanRecordedSession, summarizeLearningPathFromMaterialization, summarizeNormalizedEventExportLabelFlow, summarizeTeacherNoArtifactCycle, writeScannedEventExportBundle } from "./index.js";
+import { DEFAULT_WATCH_POLL_INTERVAL_SECONDS, buildNormalizedEventExportFromScannedEvents, bootstrapRuntimeAttach, clearOpenClawProfileRuntimeLoadProof, compileRuntimeContext, createAsyncTeacherLiveLoop, createOpenClawLocalSessionTail, createRuntimeEventExportScanner, describeCurrentProfileBrainStatusWithReport, formatOperatorRollbackReport, listOpenClawProfileRuntimeLoadProofs, loadRuntimeEventExportBundle, loadWatchTeacherSnapshotState, persistWatchTeacherSnapshot, rollbackRuntimeAttach, resolveAttachmentRuntimeLoadProofsPath, resolveOperatorTeacherSnapshotPath, resolveAsyncTeacherLiveLoopSnapshotPath, resolveWatchSessionTailCursorPath, resolveWatchStateRoot, resolveWatchTeacherSnapshotPath, scanLiveEventExport, scanRecordedSession, summarizeLearningPathFromMaterialization, summarizeNormalizedEventExportLabelFlow, summarizeTeacherNoArtifactCycle, writeScannedEventExportBundle } from "./index.js";
 import { appendLearningUpdateLogs } from "./learning-spine.js";
 import { buildPassiveLearningSessionExportFromOpenClawSessionStore } from "./local-session-passive-learning.js";
 import { reindexMaterializationCandidateWithEmbedder } from "./materialization-embedder.js";
@@ -1692,8 +1692,7 @@ function inspectInstallConvergeVerification(parsed) {
         openclawHome: parsed.openclawHome,
         ...(targetInspection.profileId === null ? {} : { profileId: targetInspection.profileId })
     };
-    const status = describeCurrentProfileBrainStatus(operatorInput);
-    const report = buildOperatorSurfaceReport(operatorInput);
+    const { status, report } = describeCurrentProfileBrainStatusWithReport(operatorInput);
     const normalizedStatusAndReport = applyAttachmentPolicyTruth(status, report);
     const installHook = summarizeStatusInstallHook(parsed.openclawHome);
     const attachmentTruth = summarizeStatusAttachmentTruth({
@@ -6364,9 +6363,10 @@ export function runOperatorCli(argv = process.argv.slice(2)) {
             : { profileId: targetInspection.profileId }),
         teacherSnapshotPath: resolveOperatorTeacherSnapshotPath(activationRoot, statusOrRollback.input.teacherSnapshotPath)
     };
-    const status = describeCurrentProfileBrainStatus(operatorInput);
+    const statusWithReport = describeCurrentProfileBrainStatusWithReport(operatorInput);
+    const status = statusWithReport.status;
     const tracedLearning = buildTracedLearningStatusSurface(activationRoot);
-    const normalizedStatusAndReport = applyAttachmentPolicyTruth(status, statusOrRollback.json ? null : buildOperatorSurfaceReport(operatorInput));
+    const normalizedStatusAndReport = applyAttachmentPolicyTruth(status, statusOrRollback.json ? null : statusWithReport.report);
     if (statusOrRollback.json) {
         console.log(JSON.stringify({
             ...normalizedStatusAndReport.status,

package/dist/src/index.js

@@ -8031,9 +8031,15 @@ export function buildOperatorSurfaceReport(input) {
         findings
     };
 }
-export function describeCurrentProfileBrainStatus(input) {
+export function describeCurrentProfileBrainStatusWithReport(input) {
     const report = buildOperatorSurfaceReport(input);
-    return buildCurrentProfileBrainStatusFromReport(report, report.manyProfile.declaredAttachmentPolicy, normalizeOptionalString(input.profileId) ?? null);
+    return {
+        report,
+        status: buildCurrentProfileBrainStatusFromReport(report, report.manyProfile.declaredAttachmentPolicy, normalizeOptionalString(input.profileId) ?? null)
+    };
+}
+export function describeCurrentProfileBrainStatus(input) {
+    return describeCurrentProfileBrainStatusWithReport(input).status;
 }
 export function formatOperatorRollbackReport(result) {
     const header = result.allowed ? (result.dryRun ? "ROLLBACK ready" : "ROLLBACK ok") : "ROLLBACK blocked";

package/dist/src/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.26",
   "description": "OpenClawBrain operator CLI package with install/status helpers, daemon controls, and import/export tooling.",
   "type": "module",
   "main": "./dist/src/index.js",