@openclawbrain/cli 0.4.24 → 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";
@@ -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 { formatOperatorLearningAttributionSummary, formatOperatorLearningPathSummary } from "./status-learning-path.js";
+import { formatOperatorAttributionCoverageSummary, formatOperatorFeedbackSummary, formatOperatorLearningAttributionSummary, 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";
@@ -1500,7 +1500,9 @@ function formatCurrentProfileStatusSummary(status, report, targetInspection, opt
             learningPath: report.learningPath,
             tracedLearning
         })}`,
+        `feedback    ${formatOperatorFeedbackSummary({ tracedLearning })}`,
         `attribution ${formatOperatorLearningAttributionSummary({ status })}`,
+        `attrCover   ${formatOperatorAttributionCoverageSummary({ tracedLearning })}`,
         `learning    state=${report.learning.backlogState} bootstrapped=${yesNo(report.learning.bootstrapped)} mode=${report.learning.mode} next=${report.learning.nextPriorityLane} priority=${report.learning.nextPriorityBucket} pending=${report.learning.pendingLive ?? "none"}/${report.learning.pendingBackfill ?? "none"} buckets=${formatLearningBuckets(report)} warn=${formatLearningWarnings(report)} lastPack=${report.learning.lastMaterializedPackId ?? "none"} detail=${report.learning.detail}`,
         `traced      ${formatTracedLearningSurface(tracedLearning)}`,
         `teacherProof ${formatTeacherLoopSummary(report)}`,
@@ -1690,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({
@@ -6362,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/proof-command.js

@@ -76,6 +76,41 @@ function writeJson(filePath, value) {
     writeText(filePath, `${JSON.stringify(value, null, 2)}\n`);
 }
 
+function readJsonObject(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    return value;
+}
+
+function parseJsonObjectText(text) {
+    if (typeof text !== "string" || text.trim().length === 0) {
+        return null;
+    }
+    try {
+        return readJsonObject(JSON.parse(text));
+    }
+    catch {
+        return null;
+    }
+}
+
+function normalizeOptionalBoolean(value) {
+    return value === true ? true : value === false ? false : null;
+}
+
+function extractInstallRestartState(text) {
+    const parsed = parseJsonObjectText(text);
+    const restart = readJsonObject(parsed?.restart ?? null);
+    if (restart === null) {
+        return null;
+    }
+    return {
+        required: normalizeOptionalBoolean(restart.required),
+        performed: normalizeOptionalBoolean(restart.performed),
+    };
+}
+
 function buildCurrentCliInvocation(cliEntryPath = process.argv[1]) {
     const normalizedEntryPath = normalizeOptionalCliString(cliEntryPath);
     if (normalizedEntryPath === null) {
@@ -511,7 +546,7 @@ function buildVerdict({ steps, gatewayStatus, pluginInspect, statusSignals, brea
     };
 }
 
-function buildSummary({ options, steps, verdict, gatewayStatusText, pluginInspectText, statusSignals, breadcrumbs, runtimeLoadProofSnapshot, guardLine, attributionLine, learningPathLine, coverageSnapshot, hardeningSnapshot }) {
+function buildSummary({ options, steps, verdict, gatewayStatusText, pluginInspectText, statusSignals, breadcrumbs, runtimeLoadProofSnapshot, guardLine, feedbackLine, attributionLine, attributionCoverageLine, learningPathLine, coverageSnapshot, hardeningSnapshot }) {
     const passed = [];
     const missing = [];
     const warnings = Array.isArray(verdict.warnings) ? verdict.warnings : [];
@@ -573,9 +608,15 @@ function buildSummary({ options, steps, verdict, gatewayStatusText, pluginInspec
             : [`- ${guardLine}`]),
         "",
         "## Learning Attribution",
+        ...(feedbackLine === null
+            ? ["- feedback line not reported by detailed status"]
+            : [`- ${feedbackLine}`]),
         ...(attributionLine === null
             ? ["- attribution line not reported by detailed status"]
             : [`- ${attributionLine}`]),
+        ...(attributionCoverageLine === null
+            ? ["- attribution coverage line not reported by detailed status"]
+            : [`- ${attributionCoverageLine}`]),
         ...(learningPathLine === null
             ? []
             : [`- ${learningPathLine}`]),
@@ -802,7 +843,7 @@ export function captureOperatorProofBundle(options) {
     mkdirSync(bundleDir, { recursive: true });
     const steps = [];
     const gatewayProfile = readOpenClawProfileName(options.openclawHome);
-    function addStep(stepId, label, command, args, { skipped = false } = {}) {
+    function addStep(stepId, label, command, args, { skipped = false, skipSummary = "step intentionally skipped" } = {}) {
         if (skipped) {
             steps.push({
                 stepId,
@@ -811,7 +852,7 @@ export function captureOperatorProofBundle(options) {
                 skipped: true,
                 captureState: "complete",
                 resultClass: "success",
-                summary: "step intentionally skipped",
+                summary: skipSummary,
                 stdoutPath: null,
                 stderrPath: null,
             });
@@ -844,8 +885,27 @@ export function captureOperatorProofBundle(options) {
         });
         return capture;
     }
-    addStep("01-install", "install", cliInvocation.command, [...cliInvocation.args, "install", "--openclaw-home", options.openclawHome], { skipped: options.skipInstall === true });
-    addStep("02-restart", "gateway restart", "openclaw", buildGatewayArgs("restart", gatewayProfile), { skipped: options.skipRestart === true });
+    const installCapture = addStep("01-install", "install", cliInvocation.command, [...cliInvocation.args, "install", "--openclaw-home", options.openclawHome, "--json"], { skipped: options.skipInstall === true });
+    const installRestartState = options.skipInstall === true || installCapture.exitCode !== 0 || installCapture.error
+        ? null
+        : extractInstallRestartState(installCapture.stdout);
+    let restartSkipSummary = null;
+    if (options.skipRestart === true) {
+        restartSkipSummary = "step intentionally skipped";
+    }
+    else if (installRestartState?.performed === true) {
+        restartSkipSummary = "step intentionally skipped because install already performed the gateway restart";
+    }
+    else if (installRestartState?.required === false) {
+        restartSkipSummary = "step intentionally skipped because install reported no gateway restart was required";
+    }
+    else if (gatewayProfile === null) {
+        restartSkipSummary = "skipped because exact OpenClaw profile token could not be inferred; avoiding shared-gateway self-interrupt during proof capture";
+    }
+    addStep("02-restart", "gateway restart", "openclaw", buildGatewayArgs("restart", gatewayProfile), {
+        skipped: restartSkipSummary !== null,
+        skipSummary: restartSkipSummary ?? undefined
+    });
     const gatewayStatusCapture = addStep("03-gateway-status", "gateway status", "openclaw", buildGatewayStatusArgs(
         gatewayProfile,
         normalizeOptionalCliString(options.gatewayUrl ?? null),
@@ -861,7 +921,9 @@ export function captureOperatorProofBundle(options) {
     const serveLine = extractDetailedStatusLine(statusCapture.stdout, "serve");
     const routeFnLine = extractDetailedStatusLine(statusCapture.stdout, "routeFn");
     const guardLine = extractDetailedStatusLine(statusCapture.stdout, "guard");
+    const feedbackLine = extractDetailedStatusLine(statusCapture.stdout, "feedback");
     const attributionLine = extractDetailedStatusLine(statusCapture.stdout, "attribution");
+    const attributionCoverageLine = extractDetailedStatusLine(statusCapture.stdout, "attrCover");
     const learningPathLine = extractDetailedStatusLine(statusCapture.stdout, "path");
     const runtimeLoadProofPath = normalizeReportedProofPath(statusSignals.proofPath)
         ?? path.join(activationRoot, "attachment-truth", "runtime-load-proofs.json");
@@ -917,7 +979,9 @@ export function captureOperatorProofBundle(options) {
         runtimeLoadProofPath,
         runtimeLoadProofError: runtimeLoadProofSnapshot.error,
         guardLine,
+        feedbackLine,
         attributionLine,
+        attributionCoverageLine,
         learningPathLine,
     });
     writeJson(path.join(bundleDir, "hardening-snapshot.json"), hardeningSnapshot);
@@ -931,7 +995,9 @@ export function captureOperatorProofBundle(options) {
         breadcrumbs,
         runtimeLoadProofSnapshot,
         guardLine,
+        feedbackLine,
         attributionLine,
+        attributionCoverageLine,
         learningPathLine,
         coverageSnapshot,
         hardeningSnapshot,
@@ -950,7 +1016,9 @@ export function captureOperatorProofBundle(options) {
         verdict,
         statusSignals,
         guardLine,
+        feedbackLine,
         attributionLine,
+        attributionCoverageLine,
         learningPathLine,
         steps,
         summaryPath: path.join(bundleDir, "summary.md"),

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

@@ -7,6 +7,29 @@ function isSeedAwaitingFirstPromotion(status) {
 function normalizeOptionalString(value) {
     return typeof value === "string" && value.trim().length > 0 ? value : null;
 }
+function formatOptionalFeedbackLatest(tracedLearning) {
+    const latestLabel = normalizeOptionalString(tracedLearning?.feedbackSummary?.latestLabel);
+    return latestLabel === null ? "" : ` latest=${latestLabel}`;
+}
+function formatOperatorFeedbackSummary({ tracedLearning }) {
+    const routeTraceCount = tracedLearning?.feedbackSummary?.routeTraceCount ?? tracedLearning?.routeTraceCount ?? 0;
+    const supervisedTraceCount = tracedLearning?.feedbackSummary?.supervisedTraceCount ?? tracedLearning?.supervisionCount ?? 0;
+    return [
+        `helpful=${tracedLearning?.feedbackSummary?.helpfulCount ?? 0}`,
+        `irrelevant=${tracedLearning?.feedbackSummary?.irrelevantCount ?? 0}`,
+        `harmful=${tracedLearning?.feedbackSummary?.harmfulCount ?? 0}`,
+        `supervisedTraceCount=${supervisedTraceCount}`,
+        `routeTraceCount=${routeTraceCount}`
+    ].join(" ") + formatOptionalFeedbackLatest(tracedLearning);
+}
+function formatOperatorAttributionCoverageSummary({ tracedLearning }) {
+    return [
+        `completedWithoutEvaluation=${tracedLearning?.attributionCoverage?.completedWithoutEvaluationCount ?? 0}`,
+        `ready=${tracedLearning?.attributionCoverage?.readyCount ?? 0}`,
+        `delayed=${tracedLearning?.attributionCoverage?.delayedCount ?? 0}`,
+        `budgetDeferred=${tracedLearning?.attributionCoverage?.budgetDeferredCount ?? 0}`
+    ].join(" ");
+}
 function formatOperatorLearningAttributionSummary({ status }) {
     const attribution = status?.learningAttribution ?? null;
     if (!attribution) {
@@ -55,4 +78,4 @@ export function formatOperatorLearningPathSummary({ status, learningPath, traced
         ...detailParts
     ].join(" ");
 }
-export { formatOperatorLearningAttributionSummary };
+export { formatOperatorAttributionCoverageSummary, formatOperatorFeedbackSummary, formatOperatorLearningAttributionSummary };

package/dist/src/traced-learning-bridge.js

@@ -15,12 +15,412 @@ function normalizeCount(value) {
 function normalizeOptionalString(value) {
     return typeof value === "string" && value.trim().length > 0 ? value : null;
 }
+function parseJsonValue(value, fallback) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        return fallback;
+    }
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return fallback;
+    }
+}
 function normalizeUnitInterval(value) {
     return Number.isFinite(value) ? Math.max(0, Math.min(1, Number(value))) : 0;
 }
 function normalizeSource(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
+function toRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function normalizeAgentIdentity(value) {
+    const record = toRecord(value);
+    const agentId = normalizeOptionalString(record?.agentId);
+    const lane = normalizeOptionalString(record?.lane);
+    return agentId === null || lane === null ? null : { agentId, lane };
+}
+function formatAgentIdentity(identity) {
+    if (identity === null) {
+        return null;
+    }
+    return identity.lane === "main" ? identity.agentId : `${identity.agentId}:${identity.lane}`;
+}
+function defaultFeedbackSummary(routeTraceCount = 0, supervisedTraceCount = 0, detail = "feedback truth is not visible in the current status surface") {
+    return {
+        visible: false,
+        helpfulCount: 0,
+        irrelevantCount: 0,
+        harmfulCount: 0,
+        supervisedTraceCount,
+        routeTraceCount,
+        latestAgentIdentity: null,
+        latestLabel: null,
+        detail
+    };
+}
+function normalizeFeedbackSummary(value, counts = {}) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        return defaultFeedbackSummary(normalizeCount(counts.routeTraceCount), normalizeCount(counts.supervisedTraceCount));
+    }
+    const routeTraceCount = normalizeCount(value.routeTraceCount ?? counts.routeTraceCount);
+    const supervisedTraceCount = normalizeCount(value.supervisedTraceCount ?? counts.supervisedTraceCount);
+    const latestAgentIdentity = normalizeAgentIdentity(value.latestAgentIdentity);
+    return {
+        visible: value.visible === true,
+        helpfulCount: normalizeCount(value.helpfulCount),
+        irrelevantCount: normalizeCount(value.irrelevantCount),
+        harmfulCount: normalizeCount(value.harmfulCount),
+        supervisedTraceCount,
+        routeTraceCount,
+        latestAgentIdentity,
+        latestLabel: normalizeOptionalString(value.latestLabel) ?? formatAgentIdentity(latestAgentIdentity),
+        detail: normalizeOptionalString(value.detail)
+            ?? (routeTraceCount === 0
+                ? "no traced routes recorded yet"
+                : `${supervisedTraceCount}/${routeTraceCount} traced routes are covered by live verdicts`)
+    };
+}
+function defaultAttributionCoverage(detail = "teacher gating truth is not visible in the current status surface") {
+    return {
+        visible: false,
+        gatingVisible: false,
+        completedWithoutEvaluationCount: 0,
+        readyCount: 0,
+        delayedCount: 0,
+        budgetDeferredCount: 0,
+        detail
+    };
+}
+function normalizeAttributionCoverage(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        return defaultAttributionCoverage();
+    }
+    return {
+        visible: value.visible === true,
+        gatingVisible: value.gatingVisible === true,
+        completedWithoutEvaluationCount: normalizeCount(value.completedWithoutEvaluationCount),
+        readyCount: normalizeCount(value.readyCount),
+        delayedCount: normalizeCount(value.delayedCount),
+        budgetDeferredCount: normalizeCount(value.budgetDeferredCount),
+        detail: normalizeOptionalString(value.detail)
+            ?? "teacher gating truth is not visible in the current status surface"
+    };
+}
+function hasNonEmptyToolResults(value) {
+    if (Array.isArray(value)) {
+        return value.length > 0;
+    }
+    return typeof value === "string" && value.trim().length > 0 && value.trim() !== "[]";
+}
+function hasTeacherBindingMode(rawEvaluation) {
+    const evaluation = parseJsonValue(rawEvaluation, null);
+    switch (evaluation?.bindingMode) {
+        case "exact_decision_id":
+        case "exact_selection_digest":
+        case "turn_compile_event_id":
+        case "trace_id":
+        case "legacy_heuristic":
+        case "unbound":
+            return true;
+        default:
+            return false;
+    }
+}
+function classifyContextFeedbackVerdict(score) {
+    if (Number(score) >= 0.25) {
+        return "helpful";
+    }
+    if (Number(score) <= -0.25) {
+        return "harmful";
+    }
+    return "irrelevant";
+}
+function isObservationReadyForTeacher(row, readyBefore) {
+    return row.status === "pending_teacher"
+        || normalizeOptionalString(row.follow_up_text) !== null
+        || hasNonEmptyToolResults(row.tool_results_json)
+        || Number(row.created_at ?? 0) <= readyBefore;
+}
+function buildDerivedFeedbackSummary(db, routeTraceCount, defaultSupervisionCount) {
+    const traceRows = db.prepare(`
+      SELECT id, route_trace_json
+      FROM brain_traces
+    `).all();
+    const traceAgentIdentityById = new Map();
+    for (const row of traceRows) {
+        const routeTrace = parseJsonValue(row?.route_trace_json, null);
+        const agentIdentity = normalizeAgentIdentity(routeTrace?.agentIdentity);
+        if (agentIdentity !== null && typeof row?.id === "string") {
+            traceAgentIdentityById.set(row.id, agentIdentity);
+        }
+    }
+    const verdictCounts = {
+        helpfulCount: 0,
+        irrelevantCount: 0,
+        harmfulCount: 0
+    };
+    const latestTraceIds = new Set();
+    let latestAgentIdentity = null;
+    const supervisionRows = db.prepare(`
+      SELECT trace_id, metadata, value
+      FROM brain_trace_supervision
+      WHERE resolution = 'promoted_to_label'
+      ORDER BY created_at DESC
+    `).all();
+    for (const row of supervisionRows) {
+        const traceId = normalizeOptionalString(row?.trace_id);
+        if (traceId === null || latestTraceIds.has(traceId)) {
+            continue;
+        }
+        latestTraceIds.add(traceId);
+        const metadata = parseJsonValue(row?.metadata, {});
+        const agentIdentity = normalizeAgentIdentity(metadata?.agentIdentity)
+            ?? traceAgentIdentityById.get(traceId)
+            ?? null;
+        if (latestAgentIdentity === null) {
+            latestAgentIdentity = agentIdentity;
+        }
+        const verdict = classifyContextFeedbackVerdict(Number(row?.value ?? 0));
+        if (verdict === "helpful") {
+            verdictCounts.helpfulCount += 1;
+        }
+        else if (verdict === "harmful") {
+            verdictCounts.harmfulCount += 1;
+        }
+        else {
+            verdictCounts.irrelevantCount += 1;
+        }
+    }
+    const supervisedTraceCount = latestTraceIds.size || normalizeCount(defaultSupervisionCount);
+    return {
+        visible: true,
+        ...verdictCounts,
+        supervisedTraceCount,
+        routeTraceCount,
+        latestAgentIdentity,
+        latestLabel: formatAgentIdentity(latestAgentIdentity),
+        detail: routeTraceCount === 0
+            ? "no traced routes recorded yet"
+            : `${verdictCounts.helpfulCount} helpful, ${verdictCounts.irrelevantCount} irrelevant, ${verdictCounts.harmfulCount} harmful; ${supervisedTraceCount}/${routeTraceCount} traced routes are supervised`
+    };
+}
+function buildDerivedAttributionCoverage(db) {
+    const completedRows = db.prepare(`
+      SELECT teacher_evaluation_json
+      FROM brain_observations
+      WHERE status = 'completed'
+    `).all();
+    const completedWithoutEvaluationCount = completedRows.reduce((sum, row) => sum + (hasTeacherBindingMode(row?.teacher_evaluation_json) ? 0 : 1), 0);
+    const evaluationCycle = loadTrainingStateJson(db, "last_teacher_evaluation_cycle_json");
+    const budgetPerTick = Number.isFinite(evaluationCycle.value?.budgetPerTick)
+        ? Math.max(0, Math.trunc(evaluationCycle.value.budgetPerTick))
+        : null;
+    const delayMs = Number.isFinite(evaluationCycle.value?.delayMs)
+        ? Math.max(0, Math.trunc(evaluationCycle.value.delayMs))
+        : null;
+    if (budgetPerTick === null || delayMs === null) {
+        return {
+            visible: true,
+            gatingVisible: false,
+            completedWithoutEvaluationCount,
+            readyCount: 0,
+            delayedCount: 0,
+            budgetDeferredCount: 0,
+            detail: "teacher gating truth is not visible in the current status surface"
+        };
+    }
+    const pendingRows = db.prepare(`
+      SELECT status, follow_up_text, tool_results_json, created_at
+      FROM brain_observations
+      WHERE status IN ('pending_followup', 'pending_teacher')
+      ORDER BY created_at ASC
+    `).all();
+    const readyBefore = Date.now() - delayMs;
+    let readyCount = 0;
+    for (const row of pendingRows) {
+        if (isObservationReadyForTeacher(row, readyBefore)) {
+            readyCount += 1;
+        }
+    }
+    const delayedCount = Math.max(0, pendingRows.length - readyCount);
+    const budgetDeferredCount = Math.max(0, readyCount - budgetPerTick);
+    return {
+        visible: true,
+        gatingVisible: true,
+        completedWithoutEvaluationCount,
+        readyCount,
+        delayedCount,
+        budgetDeferredCount,
+        detail: pendingRows.length === 0
+            ? "no teacher observations are pending"
+            : `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;
@@ -95,11 +495,13 @@ function normalizeBridgePayload(payload) {
     if (payload === null || typeof payload !== "object" || Array.isArray(payload)) {
         throw new Error("expected traced-learning bridge payload object");
     }
+    const routeTraceCount = normalizeCount(payload.routeTraceCount);
+    const supervisionCount = normalizeCount(payload.supervisionCount);
     return {
         contract: TRACED_LEARNING_BRIDGE_CONTRACT,
         updatedAt: normalizeOptionalString(payload.updatedAt) ?? new Date().toISOString(),
-        routeTraceCount: normalizeCount(payload.routeTraceCount),
-        supervisionCount: normalizeCount(payload.supervisionCount),
+        routeTraceCount,
+        supervisionCount,
         routerUpdateCount: normalizeCount(payload.routerUpdateCount),
         teacherArtifactCount: normalizeCount(payload.teacherArtifactCount),
         pgVersionRequested: normalizeOptionalString(payload.pgVersionRequested),
@@ -111,6 +513,11 @@ function normalizeBridgePayload(payload) {
         promoted: payload.promoted === true,
         baselinePersisted: payload.baselinePersisted === true,
         lastInterruptionSummary: normalizeLastInterruptionSummary(payload.lastInterruptionSummary),
+        feedbackSummary: normalizeFeedbackSummary(payload.feedbackSummary, {
+            routeTraceCount,
+            supervisedTraceCount: supervisionCount
+        }),
+        attributionCoverage: normalizeAttributionCoverage(payload.attributionCoverage),
         source: normalizeSource(payload.source)
     };
 }
@@ -122,11 +529,13 @@ function normalizePersistedStatusSurface(payload) {
     if (source === null) {
         throw new Error("expected traced-learning status surface source");
     }
+    const routeTraceCount = normalizeCount(payload.routeTraceCount);
+    const supervisionCount = normalizeCount(payload.supervisionCount);
     return {
         contract: TRACED_LEARNING_STATUS_SURFACE_CONTRACT,
         updatedAt: normalizeOptionalString(payload.updatedAt) ?? new Date().toISOString(),
-        routeTraceCount: normalizeCount(payload.routeTraceCount),
-        supervisionCount: normalizeCount(payload.supervisionCount),
+        routeTraceCount,
+        supervisionCount,
         routerUpdateCount: normalizeCount(payload.routerUpdateCount),
         teacherArtifactCount: normalizeCount(payload.teacherArtifactCount),
         pgVersionRequested: normalizeOptionalString(payload.pgVersionRequested),
@@ -138,6 +547,11 @@ function normalizePersistedStatusSurface(payload) {
         promoted: payload.promoted === true,
         baselinePersisted: payload.baselinePersisted === true,
         lastInterruptionSummary: normalizeLastInterruptionSummary(payload.lastInterruptionSummary),
+        feedbackSummary: normalizeFeedbackSummary(payload.feedbackSummary, {
+            routeTraceCount,
+            supervisedTraceCount: supervisionCount
+        }),
+        attributionCoverage: normalizeAttributionCoverage(payload.attributionCoverage),
         source
     };
 }
@@ -157,6 +571,8 @@ function defaultSurface(pathname, detail, error = null) {
         promoted: false,
         baselinePersisted: false,
         lastInterruptionSummary: null,
+        feedbackSummary: defaultFeedbackSummary(),
+        attributionCoverage: defaultAttributionCoverage(),
         source: null,
         detail,
         error
@@ -278,6 +694,8 @@ function buildPersistedStatusSurfaceBridge(summary, context) {
         promoted: summary.promoted,
         baselinePersisted: summary.baselinePersisted,
         lastInterruptionSummary: summary.lastInterruptionSummary,
+        feedbackSummary: summary.feedbackSummary,
+        attributionCoverage: summary.attributionCoverage,
         source: {
             command: "brain-store",
             bridge: TRACED_LEARNING_STATUS_SURFACE_BRIDGE,
@@ -321,6 +739,20 @@ function buildDerivedBrainStoreBridge(db, context, lastInterruptionSummary = nul
         ? null
         : JSON.parse(candidateUpdateRaw);
     const candidatePackVersion = Number.parseInt(candidatePackVersionRaw ?? "", 10);
+    let feedbackSummary = defaultFeedbackSummary(routeTraceCount, supervisionCount);
+    try {
+        feedbackSummary = buildDerivedFeedbackSummary(db, routeTraceCount, supervisionCount);
+    }
+    catch {
+        feedbackSummary = defaultFeedbackSummary(routeTraceCount, supervisionCount);
+    }
+    let attributionCoverage = defaultAttributionCoverage();
+    try {
+        attributionCoverage = buildDerivedAttributionCoverage(db);
+    }
+    catch {
+        attributionCoverage = defaultAttributionCoverage();
+    }
     return normalizeBridgePayload({
         updatedAt: toIsoTimestamp(candidateUpdate?.generatedAt),
         routeTraceCount,
@@ -336,6 +768,8 @@ function buildDerivedBrainStoreBridge(db, context, lastInterruptionSummary = nul
         promoted: false,
         baselinePersisted: false,
         lastInterruptionSummary,
+        feedbackSummary,
+        attributionCoverage,
         source: {
             command: "brain-store",
             bridge: "brain_store_state",
@@ -360,6 +794,13 @@ function hasMeaningfulTracedLearningSignal(bridge) {
         bridge.pgVersionUsed !== null ||
         bridge.fallbackReason !== null ||
         bridge.routerNoOpReason !== null ||
+        bridge.feedbackSummary.helpfulCount > 0 ||
+        bridge.feedbackSummary.irrelevantCount > 0 ||
+        bridge.feedbackSummary.harmfulCount > 0 ||
+        bridge.attributionCoverage.completedWithoutEvaluationCount > 0 ||
+        bridge.attributionCoverage.readyCount > 0 ||
+        bridge.attributionCoverage.delayedCount > 0 ||
+        bridge.attributionCoverage.budgetDeferredCount > 0 ||
         Number.isFinite(bridge.source?.candidatePackVersion) ||
         normalizeCount(bridge.source?.candidateUpdateCount) > 0;
 }
@@ -479,27 +920,41 @@ export function loadBrainStoreTracedLearningBridge(options = {}) {
     try {
         db = new sqlite.DatabaseSync(dbPath, { readOnly: true });
         const lastInterruptionSummary = loadLastAssemblyInterruptionSummary(db);
+        let derived = null;
+        try {
+            derived = buildDerivedBrainStoreBridge(db, {
+                brainRoot,
+                dbPath
+            }, lastInterruptionSummary);
+        }
+        catch {
+            derived = null;
+        }
         const persisted = loadPersistedStatusSurface(db, {
             brainRoot,
             dbPath
         });
         if (persisted.bridge !== null) {
-            const bridge = lastInterruptionSummary === null
-                ? persisted.bridge
-                : normalizeBridgePayload({
-                    ...persisted.bridge,
-                    lastInterruptionSummary
-                });
+            const bridge = normalizeBridgePayload({
+                ...persisted.bridge,
+                lastInterruptionSummary: lastInterruptionSummary ?? persisted.bridge.lastInterruptionSummary,
+                feedbackSummary: derived?.feedbackSummary ?? persisted.bridge.feedbackSummary,
+                attributionCoverage: derived?.attributionCoverage ?? persisted.bridge.attributionCoverage
+            });
             return {
                 path: dbPath,
                 bridge,
                 error: null
             };
         }
-        const bridge = buildDerivedBrainStoreBridge(db, {
-            brainRoot,
-            dbPath
-        }, lastInterruptionSummary);
+        const bridge = derived;
+        if (bridge === null) {
+            return {
+                path: dbPath,
+                bridge: null,
+                error: persisted.error
+            };
+        }
         if (!hasMeaningfulTracedLearningSignal(bridge)) {
             return {
                 path: dbPath,
@@ -565,6 +1020,8 @@ function buildStatusSurface(pathname, bridge, options = {}) {
         promoted: bridge.promoted,
         baselinePersisted: bridge.baselinePersisted,
         lastInterruptionSummary: bridge.lastInterruptionSummary,
+        feedbackSummary: bridge.feedbackSummary,
+        attributionCoverage: bridge.attributionCoverage,
         source: bridge.source,
         detail: detailParts.join(" "),
         error: options.error ?? null
@@ -611,6 +1068,8 @@ function mergeCanonicalStatusBridge(canonicalBridge, runtimeLoaded) {
             promoted: canonicalBridge.promoted,
             baselinePersisted: canonicalBridge.baselinePersisted,
             lastInterruptionSummary: canonicalBridge.lastInterruptionSummary ?? runtimeBridge?.lastInterruptionSummary ?? null,
+            feedbackSummary: canonicalBridge.feedbackSummary,
+            attributionCoverage: canonicalBridge.attributionCoverage,
             fallbackReason: canonicalBridge.fallbackReason,
             routerNoOpReason: canonicalBridge.routerNoOpReason,
             source: runtimeMaterialized === null
@@ -634,6 +1093,8 @@ function mergeCanonicalStatusBridge(canonicalBridge, runtimeLoaded) {
         promoted: runtimeBridge?.promoted ?? canonicalBridge.promoted,
         baselinePersisted: runtimeBridge?.baselinePersisted ?? canonicalBridge.baselinePersisted,
         lastInterruptionSummary: canonicalBridge.lastInterruptionSummary ?? runtimeBridge?.lastInterruptionSummary ?? null,
+        feedbackSummary: canonicalBridge.feedbackSummary,
+        attributionCoverage: canonicalBridge.attributionCoverage,
         fallbackReason: runtimeBridge?.fallbackReason ?? canonicalBridge.fallbackReason ?? null,
         routerNoOpReason: runtimeBridge?.routerNoOpReason ?? canonicalBridge.routerNoOpReason ?? null,
         source: runtimeMaterialized === null
@@ -655,11 +1116,16 @@ export function mergeTracedLearningBridgePayload(payload, persisted) {
     const routerUpdateCount = Math.max(current.routerUpdateCount, persistedBridge.routerUpdateCount);
     const teacherArtifactCount = Math.max(current.teacherArtifactCount, persistedBridge.teacherArtifactCount);
     const lastInterruptionSummary = current.lastInterruptionSummary ?? persistedBridge.lastInterruptionSummary ?? null;
+    const feedbackSummary = current.feedbackSummary.visible ? current.feedbackSummary : persistedBridge.feedbackSummary;
+    const attributionCoverage = current.attributionCoverage.visible ? current.attributionCoverage : persistedBridge.attributionCoverage;
     const usedBridge = routeTraceCount !== current.routeTraceCount ||
         supervisionCount !== current.supervisionCount ||
         routerUpdateCount !== current.routerUpdateCount ||
         teacherArtifactCount !== current.teacherArtifactCount ||
-        lastInterruptionSummary !== current.lastInterruptionSummary;
+        lastInterruptionSummary !== current.lastInterruptionSummary ||
+        feedbackSummary.visible !== current.feedbackSummary.visible ||
+        attributionCoverage.visible !== current.attributionCoverage.visible ||
+        attributionCoverage.gatingVisible !== current.attributionCoverage.gatingVisible;
     if (!usedBridge) {
         return current;
     }
@@ -670,6 +1136,8 @@ export function mergeTracedLearningBridgePayload(payload, persisted) {
         routerUpdateCount,
         teacherArtifactCount,
         lastInterruptionSummary,
+        feedbackSummary,
+        attributionCoverage,
         routerNoOpReason: supervisionCount > 0 || routerUpdateCount > 0 ? null : current.routerNoOpReason,
         source: {
             ...(current.source ?? {}),
@@ -690,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.24",
+  "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",