@openclawbrain/cli 0.4.15 → 0.4.16

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 } 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, writeScannedEventExportBundle } from "./index.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 { appendLearningUpdateLogs } from "./learning-spine.js";
 import { buildPassiveLearningSessionExportFromOpenClawSessionStore } from "./local-session-passive-learning.js";
 import { reindexMaterializationCandidateWithEmbedder } from "./materialization-embedder.js";
@@ -682,14 +682,14 @@ const LEARNING_WARNING_MESSAGES = {
     passive_backfill_pending: "passive backfill remains queued",
     teacher_queue_full: "teacher queue is full",
     teacher_labels_stale: "teacher labels are stale",
-    teacher_no_artifacts: "teacher produced no artifacts",
+    teacher_no_artifacts: "latest no-op cycle had teachable material but no new teacher artifact",
     teacher_snapshot_unavailable: "teacher snapshot is unavailable"
 };
 const TEACHER_NO_OP_MESSAGES = {
     none: "the latest processed export produced teacher artifacts",
     duplicate_export: "the latest cycle was a no-op because the export was already seen",
     queue_full: "the latest cycle was a no-op because the teacher queue was full",
-    no_teacher_artifacts: "the latest cycle was a no-op because no teacher artifacts were produced",
+    no_teacher_artifacts: "the latest cycle produced no new teacher artifacts",
     empty_scan: "the latest cycle was a no-op because the scanner did not produce any events",
     unavailable: "the latest cycle is not visible from the current operator snapshot"
 };
@@ -1089,7 +1089,9 @@ function summarizeStatusTeacher(report, providerConfig, localLlm) {
     const healthy = report.teacherLoop.failureMode === "none" &&
         stale === false &&
         report.teacherLoop.watchState !== "not_visible";
-    const cycleDetail = TEACHER_NO_OP_MESSAGES[report.teacherLoop.lastNoOpReason] ?? "the latest teacher cycle detail is unavailable";
+    const cycleDetail = report.teacherLoop.lastNoOpReason === "no_teacher_artifacts"
+        ? summarizeTeacherNoArtifactCycle(report.teacherLoop.notes).detail
+        : TEACHER_NO_OP_MESSAGES[report.teacherLoop.lastNoOpReason] ?? "the latest teacher cycle detail is unavailable";
     if (report.teacherLoop.failureMode !== "none" && report.teacherLoop.failureMode !== "unavailable") {
         return {
             model: providerConfig.teacher.model,

package/dist/src/index.d.ts

@@ -5,7 +5,7 @@ import { type AdvanceAlwaysOnLearningRuntimeInput, type AlwaysOnLearningCadenceV
 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";
-export { createHttpOllamaTeacherLabelerClient, createOllamaTeacherLabeler, createTeacherLabeler, type AsyncTeacherLabelerConfigV1, type AsyncTeacherNoopLabelerConfigV1, type AsyncTeacherOllamaLabelerConfigV1, type OllamaTeacherLabelerClient, type TeacherLabeler, type TeacherLabelerResultV1, type TeacherLabelerRunInputV1 } from "./teacher-labeler.js";
+export { createHttpOllamaTeacherLabelerClient, createOllamaTeacherLabeler, createTeacherLabeler, summarizeTeacherLabelerOpportunity, type AsyncTeacherLabelerConfigV1, type AsyncTeacherNoopLabelerConfigV1, type AsyncTeacherOllamaLabelerConfigV1, type OllamaTeacherLabelerClient, type TeacherLabeler, type TeacherLabelerOpportunityInputV1, type TeacherLabelerOpportunityV1, type TeacherLabelerResultV1, type TeacherLabelerRunInputV1 } from "./teacher-labeler.js";
 export declare const DEFAULT_ASYNC_TEACHER_QUEUE_CAPACITY = 8;
 declare const RECORDED_SESSION_TRACE_CONTRACT: "recorded_session_trace.v1";
 declare const RECORDED_SESSION_FIXTURE_CONTRACT: "recorded_session_replay_fixture.v1";
@@ -401,6 +401,10 @@ export interface AsyncTeacherLiveLoopInput extends Pick<AdvanceAlwaysOnLearningR
     persistUpdatedBaseline?: (state: BaselineStateV1) => void;
     teacherLabeler?: AsyncTeacherLabelerConfigV1 | null;
 }
+export interface TeacherNoArtifactCycleSummaryV1 {
+    shouldWarn: boolean;
+    detail: string;
+}
 export interface AsyncTeacherQueuedExportJobV1 {
     jobId: string;
     exportDigest: string;
@@ -681,6 +685,7 @@ export declare const WATCH_STATE_DIRNAME = "watch";
 export declare const WATCH_SESSION_TAIL_CURSOR_BASENAME = "session-tail-cursor.json";
 export declare const WATCH_TEACHER_SNAPSHOT_BASENAME = "teacher-snapshot.json";
 export declare const DEFAULT_WATCH_POLL_INTERVAL_SECONDS = 30;
+export declare function summarizeTeacherNoArtifactCycle(notes: readonly string[] | null | undefined): TeacherNoArtifactCycleSummaryV1;
 export interface WatchTeacherSnapshotFailureV1 {
     mode: "materialization_failed" | "teacher_fail_open";
     detail: string;

package/dist/src/index.js

@@ -12,8 +12,8 @@ import { inspectOpenClawBrainHookStatus, summarizeOpenClawBrainHookLoad } from "
 import { appendLearningUpdateLogs, appendServeTimeRouteDecisionLog } from "./learning-spine.js";
 import { buildFeedbackSemanticMetadata, buildInteractionSemanticMetadata } from "./semantic-metadata.js";
 export { clearOpenClawProfileRuntimeLoadProof, listOpenClawProfileRuntimeLoadProofs, recordOpenClawProfileRuntimeLoadProof, resolveAttachmentRuntimeLoadProofsPath } from "./attachment-truth.js";
-import { createTeacherLabeler } from "./teacher-labeler.js";
-export { createHttpOllamaTeacherLabelerClient, createOllamaTeacherLabeler, createTeacherLabeler } from "./teacher-labeler.js";
+import { createTeacherLabeler, summarizeTeacherLabelerOpportunity } from "./teacher-labeler.js";
+export { createHttpOllamaTeacherLabelerClient, createOllamaTeacherLabeler, createTeacherLabeler, summarizeTeacherLabelerOpportunity } from "./teacher-labeler.js";
 const DEFAULT_AGENT_ID = "openclaw-runtime";
 const FEEDBACK_KINDS = new Set(["correction", "teaching", "approval", "suppression"]);
 export const DEFAULT_ASYNC_TEACHER_QUEUE_CAPACITY = 8;
@@ -250,9 +250,45 @@ function buildAsyncTeacherLoopNotes(input) {
         `teacher_noop=${input.noOpReason}`,
         `teacher_labeler=${input.teacherLabeler?.status ?? "disabled"}`,
         `teacher_labeler_detail=${input.teacherLabeler?.detail ?? "disabled"}`,
+        `teacher_last_cycle_deterministic_artifacts=${input.lastCycle?.deterministicArtifactCount ?? "unknown"}`,
+        `teacher_last_cycle_new_deterministic_artifacts=${input.lastCycle?.newDeterministicArtifactCount ?? "unknown"}`,
+        `teacher_last_cycle_labeler_candidates=${input.lastCycle?.labelerCandidateCount ?? "unknown"}`,
+        `teacher_last_cycle_labeler_budgeted_candidates=${input.lastCycle?.labelerBudgetedCandidateCount ?? "unknown"}`,
+        `teacher_last_cycle_labeler_status=${input.lastCycle?.labelerStatus ?? "unknown"}`,
+        `teacher_last_cycle_labeler_detail=${input.lastCycle?.labelerDetail ?? "unknown"}`,
         input.materialization === null ? "teacher_materialization=noop" : `teacher_materialized_pack=${input.materialization.candidate.summary.packId}`
     ];
 }
+function parseAsyncTeacherLastCycleNotes(notes) {
+    const values = new Map();
+    for (const note of notes) {
+        const separator = note.indexOf("=");
+        if (separator <= 0) {
+            continue;
+        }
+        values.set(note.slice(0, separator), note.slice(separator + 1));
+    }
+    const readNullableNumber = (key) => {
+        const raw = values.get(key);
+        if (raw === undefined || raw === "unknown") {
+            return null;
+        }
+        const parsed = Number.parseInt(raw, 10);
+        return Number.isFinite(parsed) ? parsed : null;
+    };
+    const readNullableString = (key) => {
+        const raw = values.get(key);
+        return raw === undefined || raw === "unknown" ? null : raw;
+    };
+    return {
+        deterministicArtifactCount: readNullableNumber("teacher_last_cycle_deterministic_artifacts"),
+        newDeterministicArtifactCount: readNullableNumber("teacher_last_cycle_new_deterministic_artifacts"),
+        labelerCandidateCount: readNullableNumber("teacher_last_cycle_labeler_candidates"),
+        labelerBudgetedCandidateCount: readNullableNumber("teacher_last_cycle_labeler_budgeted_candidates"),
+        labelerStatus: readNullableString("teacher_last_cycle_labeler_status"),
+        labelerDetail: readNullableString("teacher_last_cycle_labeler_detail")
+    };
+}
 function cloneAlwaysOnLearningMaterializationJobOrNull(value) {
     return value === null ? null : structuredClone(value);
 }
@@ -565,6 +601,14 @@ export class AsyncTeacherLiveLoop {
     learnerState = createAlwaysOnLearningRuntimeState();
     lastMaterialization = null;
     lastTeacherLabelerResult = null;
+    lastCycle = {
+        deterministicArtifactCount: null,
+        newDeterministicArtifactCount: null,
+        labelerCandidateCount: null,
+        labelerBudgetedCandidateCount: null,
+        labelerStatus: null,
+        labelerDetail: null
+    };
     diagnostics = {
         acceptedExportCount: 0,
         processedExportCount: 0,
@@ -584,7 +628,8 @@ export class AsyncTeacherLiveLoop {
             sparseFeedback: this.learnerState.sparseFeedback,
             noOpReason: "none",
             materialization: null,
-            teacherLabeler: null
+            teacherLabeler: null,
+            lastCycle: this.lastCycle
         })
     };
     constructor(input) {
@@ -612,6 +657,7 @@ export class AsyncTeacherLiveLoop {
                 ...structuredClone(resumedSnapshot.diagnostics),
                 notes: [...resumedSnapshot.diagnostics.notes]
             };
+            this.lastCycle = parseAsyncTeacherLastCycleNotes(this.diagnostics.notes);
             for (const exportDigest of resumedSnapshot.state?.seenExportDigests ?? []) {
                 this.seenExportDigests.add(exportDigest);
             }
@@ -858,6 +904,19 @@ export class AsyncTeacherLiveLoop {
                     feedbackEvents: this.feedbackEvents
                 });
                 const learnedRoutingState = this.input.resolveLearnedRoutingState?.() ?? {};
+                const currentDedupIds = new Set(this.teacherArtifacts.map((artifact) => artifact.dedupId));
+                const currentCycleBuiltArtifacts = buildTeacherSupervisionArtifactsFromNormalizedEventExport({
+                    normalizedEventExport: job.normalizedEventExport,
+                    observedAt: job.observedAt,
+                    staleAfterMs: this.staleAfterMs,
+                    ...(this.input.sparseFeedback !== undefined ? { sparseFeedback: this.input.sparseFeedback } : {})
+                });
+                const currentCycleOpportunity = summarizeTeacherLabelerOpportunity({
+                    normalizedEventExport: job.normalizedEventExport,
+                    ...(learnedRoutingState.serveTimeDecisions !== undefined
+                        ? { serveTimeDecisions: learnedRoutingState.serveTimeDecisions }
+                        : {})
+                }, this.input.teacherLabeler ?? null);
                 const builtArtifacts = buildTeacherSupervisionArtifactsFromNormalizedEventExport({
                     normalizedEventExport: mergedNormalizedEventExport,
                     observedAt: job.observedAt,
@@ -887,10 +946,21 @@ export class AsyncTeacherLiveLoop {
                     }
                 }
                 const nextBuiltArtifacts = mergeTeacherArtifacts([], [...builtArtifacts, ...generatedTeacherArtifacts]);
-                const currentDedupIds = new Set(this.teacherArtifacts.map((artifact) => artifact.dedupId));
                 const nextTeacherArtifacts = mergeTeacherArtifacts(this.teacherArtifacts, nextBuiltArtifacts);
                 const emittedArtifactCount = nextBuiltArtifacts.filter((artifact) => !currentDedupIds.has(artifact.dedupId)).length;
                 const dedupedArtifactCount = nextBuiltArtifacts.length - emittedArtifactCount;
+                this.lastCycle = {
+                    deterministicArtifactCount: currentCycleBuiltArtifacts.length,
+                    newDeterministicArtifactCount: currentCycleBuiltArtifacts.filter((artifact) => !currentDedupIds.has(artifact.dedupId)).length,
+                    labelerCandidateCount: currentCycleOpportunity.candidateCount,
+                    labelerBudgetedCandidateCount: currentCycleOpportunity.budgetedCandidateCount,
+                    labelerStatus: currentCycleOpportunity.candidateCount === 0
+                        ? currentCycleOpportunity.status
+                        : this.lastTeacherLabelerResult?.status ?? (currentCycleOpportunity.enabled ? "unknown" : "disabled"),
+                    labelerDetail: currentCycleOpportunity.candidateCount === 0
+                        ? currentCycleOpportunity.detail
+                        : this.lastTeacherLabelerResult?.detail ?? currentCycleOpportunity.detail
+                };
                 this.teacherArtifacts = nextTeacherArtifacts;
                 const learnerResult = advanceAlwaysOnLearningRuntime({
                     packLabel: this.input.packLabel,
@@ -952,7 +1022,8 @@ export class AsyncTeacherLiveLoop {
             sparseFeedback: this.learnerState.sparseFeedback,
             noOpReason: this.diagnostics.lastNoOpReason,
             materialization: this.lastMaterialization,
-            teacherLabeler: this.lastTeacherLabelerResult
+            teacherLabeler: this.lastTeacherLabelerResult,
+            lastCycle: this.lastCycle
         });
     }
 }
@@ -6981,11 +7052,104 @@ function summarizeLearningWarningStates(input) {
     if (input.teacherSnapshot.diagnostics.latestFreshness === "stale" && input.teacherSnapshot.diagnostics.lastNoOpReason !== "no_teacher_artifacts") {
         warnings.add("teacher_labels_stale");
     }
-    if (input.teacherSnapshot.diagnostics.lastNoOpReason === "no_teacher_artifacts") {
+    if (input.teacherSnapshot.diagnostics.lastNoOpReason === "no_teacher_artifacts" &&
+        summarizeTeacherNoArtifactCycle(input.teacherSnapshot.diagnostics.notes).shouldWarn) {
         warnings.add("teacher_no_artifacts");
     }
     return [...warnings];
 }
+export function summarizeTeacherNoArtifactCycle(notes) {
+    const values = new Map();
+    for (const note of notes ?? []) {
+        const separator = note.indexOf("=");
+        if (separator <= 0) {
+            continue;
+        }
+        values.set(note.slice(0, separator), note.slice(separator + 1));
+    }
+    const readNullableNumber = (key) => {
+        const raw = values.get(key);
+        if (raw === undefined || raw === "unknown") {
+            return null;
+        }
+        const parsed = Number.parseInt(raw, 10);
+        return Number.isFinite(parsed) ? parsed : null;
+    };
+    const readNullableString = (key) => {
+        const raw = values.get(key);
+        return raw === undefined || raw === "unknown" ? null : raw;
+    };
+    const deterministicArtifactCount = readNullableNumber("teacher_last_cycle_deterministic_artifacts");
+    const newDeterministicArtifactCount = readNullableNumber("teacher_last_cycle_new_deterministic_artifacts");
+    const labelerCandidateCount = readNullableNumber("teacher_last_cycle_labeler_candidates");
+    const labelerBudgetedCandidateCount = readNullableNumber("teacher_last_cycle_labeler_budgeted_candidates");
+    const labelerStatus = readNullableString("teacher_last_cycle_labeler_status");
+    const labelerDetail = readNullableString("teacher_last_cycle_labeler_detail");
+    if (deterministicArtifactCount === null && labelerCandidateCount === null) {
+        return {
+            shouldWarn: true,
+            detail: "the latest cycle produced no new teacher artifacts, and the snapshot did not say whether any teachable material was present"
+        };
+    }
+    if ((deterministicArtifactCount ?? 0) === 0 && (labelerCandidateCount ?? 0) === 0) {
+        return {
+            shouldWarn: false,
+            detail: "the latest cycle produced no new teacher artifacts because the current export had no eligible feedback, operator overrides, or matched interaction text"
+        };
+    }
+    if ((deterministicArtifactCount ?? 0) > 0 &&
+        (newDeterministicArtifactCount ?? 0) === 0 &&
+        (labelerCandidateCount ?? 0) === 0) {
+        return {
+            shouldWarn: false,
+            detail: "the latest cycle produced no new teacher artifacts because the current export only repeated supervision that was already captured"
+        };
+    }
+    if ((labelerCandidateCount ?? 0) > 0) {
+        if ((labelerBudgetedCandidateCount ?? labelerCandidateCount) === 0) {
+            return {
+                shouldWarn: true,
+                detail: "the latest cycle produced no new teacher artifacts because candidate interactions exceeded the teacher labeler prompt budget"
+            };
+        }
+        if (labelerStatus === "disabled") {
+            return {
+                shouldWarn: false,
+                detail: "the latest cycle produced no new teacher artifacts because candidate interactions existed, but the background teacher labeler is disabled"
+            };
+        }
+        if (labelerStatus === "ok") {
+            return {
+                shouldWarn: false,
+                detail: "the latest cycle produced no new teacher artifacts because candidate interactions were evaluated but did not add a new reusable label"
+            };
+        }
+        if (labelerStatus === "fail_open") {
+            return {
+                shouldWarn: true,
+                detail: labelerDetail === null
+                    ? "the latest cycle produced no new teacher artifacts because the teacher labeler failed open while candidate interactions were present"
+                    : `the latest cycle produced no new teacher artifacts because the teacher labeler failed open while candidate interactions were present: ${labelerDetail}`
+            };
+        }
+        if (labelerDetail === "no_labels_emitted") {
+            return {
+                shouldWarn: true,
+                detail: "the latest cycle produced no new teacher artifacts even though candidate interactions were present; the teacher labeler emitted no reusable labels"
+            };
+        }
+        return {
+            shouldWarn: true,
+            detail: labelerDetail === null
+                ? "the latest cycle produced no new teacher artifacts even though candidate interactions were present"
+                : `the latest cycle produced no new teacher artifacts even though candidate interactions were present: ${labelerDetail}`
+        };
+    }
+    return {
+        shouldWarn: true,
+        detail: "the latest cycle produced no new teacher artifacts even though teachable material was present"
+    };
+}
 function summarizeAlwaysOnLearning(input, active) {
     const unavailableLag = {
         activeEventRangeEnd: active?.eventRange.end ?? null,

package/dist/src/install-converge.js

@@ -142,9 +142,10 @@ export function classifyOpenClawBrainConvergeVerification(input) {
   if (displayedStatus === "fail") {
     blockingReasons.push("status still reports fail");
   }
-  const runtimeTruthAlreadyProven = displayedStatus === "ok"
-    && runtimeLoad === "proven"
-    && loadProof === "status_probe_ready";
+  const runtimeTruthAlreadyProven = runtimeLoad === "proven"
+    && loadProof === "status_probe_ready"
+    && installState === "installed"
+    && loadability === "loadable";
   if (input.restartRequired === true && input.restartPerformed !== true && !runtimeTruthAlreadyProven) {
     blockingReasons.push("restart is still required before runtime load can be trusted");
   }

package/dist/src/local-learner.js

@@ -4854,8 +4854,10 @@ function isCarryForwardSeedBlock(block) {
     if (typeof block.text !== "string" || block.text.trim().length === 0) {
         return false;
     }
-    return block.initSeed !== undefined ||
-        block.semantic?.sourceKind === "recorded_session_seed" ||
+    // Only true seed-session evidence should survive prefix-changing promotions.
+    // Ordinary runtime-turn feedback is re-materialized from learnedEventExport;
+    // carrying it forward under the old runtime-graph id duplicates evidence.
+    return block.semantic?.sourceKind === "recorded_session_seed" ||
         block.source.includes("/seed:");
 }
 function carryForwardSeedBlockScore(block) {

package/dist/src/proof-command.js

@@ -398,8 +398,10 @@ function buildVerdict({ steps, gatewayStatus, pluginInspect, statusSignals, brea
     const runtimeProofMatched = Array.isArray(runtimeLoadProofSnapshot?.value?.profiles)
         && runtimeLoadProofSnapshot.value.profiles.some((profile) => canonicalizeExistingProofPath(profile?.openclawHome ?? "") === canonicalizeExistingProofPath(openclawHome));
     const runtimeTruthGaps = [];
-    if (!statusSignals.statusOk)
-        runtimeTruthGaps.push("status_ok");
+    const strongRuntimeTruth = statusSignals.loadProofReady
+        && statusSignals.runtimeProven
+        && statusSignals.serveActivePack
+        && statusSignals.routeFnAvailable;
     if (!statusSignals.loadProofReady)
         runtimeTruthGaps.push("load_proof");
     if (!statusSignals.runtimeProven)
@@ -410,6 +412,15 @@ function buildVerdict({ steps, gatewayStatus, pluginInspect, statusSignals, brea
         runtimeTruthGaps.push("route_fn");
     const warningCodes = [];
     const warnings = [];
+    if (!statusSignals.statusOk) {
+        if (strongRuntimeTruth) {
+            warningCodes.push("status_warn");
+            warnings.push("detailed status did not return STATUS ok, but loadProof/runtime/serve/routeFn proofs stayed healthy");
+        }
+        else {
+            runtimeTruthGaps.push("status_ok");
+        }
+    }
     if (!gatewayHealthy) {
         warningCodes.push("gateway_health");
         warnings.push("gateway status did not confirm runtime running and RPC probe ok");
@@ -597,6 +608,17 @@ function buildGatewayArgs(action, profileName) {
         : ["gateway", action, "--profile", profileName];
 }
 
+function buildGatewayStatusArgs(profileName, gatewayUrl, gatewayToken) {
+    const args = buildGatewayArgs("status", profileName);
+    if (gatewayUrl !== null) {
+        args.push("--url", gatewayUrl);
+    }
+    if (gatewayToken !== null) {
+        args.push("--token", gatewayToken);
+    }
+    return args;
+}
+
 export function buildProofCommandForOpenClawHome(openclawHome) {
     return `openclawbrain proof --openclaw-home ${quoteShellArg(path.resolve(openclawHome))}`;
 }
@@ -609,6 +631,8 @@ export function buildProofCommandHelpSection() {
             "  --skip-install              Capture proof without rerunning install first (proof only).",
             "  --skip-restart              Capture proof without restarting OpenClaw first (proof only).",
             `  --plugin-id <id>            Plugin id for \`openclaw plugins inspect\` (proof only; default: ${DEFAULT_OPERATOR_PROOF_PLUGIN_ID}).`,
+            "  --gateway-url <url>         Override the gateway-status probe target for proof capture (proof only).",
+            "  --gateway-token <token>     Gateway token to use with --gateway-url or other non-default proof probes.",
             `  --timeout-ms <ms>           Per-step timeout in ms for proof capture (proof only; default: ${DEFAULT_OPERATOR_PROOF_TIMEOUT_MS}).`,
         ],
         lifecycle: "  5. proof              openclawbrain proof --openclaw-home <path> - capture one durable operator proof bundle after install/restart/status",
@@ -624,6 +648,8 @@ export function parseProofCliArgs(argv, options = {}) {
     let skipInstall = false;
     let skipRestart = false;
     let pluginId = DEFAULT_OPERATOR_PROOF_PLUGIN_ID;
+    let gatewayUrl = null;
+    let gatewayToken = null;
     let timeoutMs = DEFAULT_OPERATOR_PROOF_TIMEOUT_MS;
     let json = false;
     let help = false;
@@ -681,6 +707,24 @@ export function parseProofCliArgs(argv, options = {}) {
             index += 1;
             continue;
         }
+        if (arg === "--gateway-url") {
+            const next = argv[index + 1];
+            if (next === undefined) {
+                throw new Error("--gateway-url requires a value");
+            }
+            gatewayUrl = next;
+            index += 1;
+            continue;
+        }
+        if (arg === "--gateway-token") {
+            const next = argv[index + 1];
+            if (next === undefined) {
+                throw new Error("--gateway-token requires a value");
+            }
+            gatewayToken = next;
+            index += 1;
+            continue;
+        }
         if (arg === "--timeout-ms") {
             const next = argv[index + 1];
             if (next === undefined) {
@@ -705,6 +749,8 @@ export function parseProofCliArgs(argv, options = {}) {
             skipInstall,
             skipRestart,
             pluginId,
+            gatewayUrl,
+            gatewayToken,
             timeoutMs,
             json,
             help
@@ -725,6 +771,8 @@ export function parseProofCliArgs(argv, options = {}) {
         skipInstall,
         skipRestart,
         pluginId,
+        gatewayUrl,
+        gatewayToken,
         timeoutMs,
         json,
         help
@@ -783,7 +831,11 @@ export function captureOperatorProofBundle(options) {
     }
     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 gatewayStatusCapture = addStep("03-gateway-status", "gateway status", "openclaw", buildGatewayArgs("status", gatewayProfile));
+    const gatewayStatusCapture = addStep("03-gateway-status", "gateway status", "openclaw", buildGatewayStatusArgs(
+        gatewayProfile,
+        normalizeOptionalCliString(options.gatewayUrl ?? null),
+        normalizeOptionalCliString(options.gatewayToken ?? null),
+    ));
     const pluginInspectCapture = addStep("04-plugin-inspect", "plugin inspect", "openclaw", ["plugins", "inspect", options.pluginId]);
     const statusCapture = addStep("05-detailed-status", "detailed status", cliInvocation.command, [...cliInvocation.args, "status", "--openclaw-home", options.openclawHome, "--detailed"]);
     const gatewayLogPath = extractGatewayLogPath(gatewayStatusCapture.stdout);

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

@@ -15,6 +15,17 @@ export interface TeacherLabelerResultV1 {
 export interface TeacherLabeler {
     label(input: TeacherLabelerRunInputV1): Promise<TeacherLabelerResultV1>;
 }
+export interface TeacherLabelerOpportunityInputV1 {
+    normalizedEventExport: NormalizedEventExportV1;
+    serveTimeDecisions?: readonly LearningSpineServeRouteDecisionLogEntryV1[];
+}
+export interface TeacherLabelerOpportunityV1 {
+    enabled: boolean;
+    candidateCount: number;
+    budgetedCandidateCount: number;
+    status: "disabled" | "ready" | "skipped";
+    detail: string;
+}
 export interface OllamaTeacherLabelerGenerateInputV1 {
     model: string;
     prompt: string;
@@ -47,4 +58,5 @@ export interface AsyncTeacherNoopLabelerConfigV1 {
 export type AsyncTeacherLabelerConfigV1 = AsyncTeacherNoopLabelerConfigV1 | AsyncTeacherOllamaLabelerConfigV1;
 export declare function createHttpOllamaTeacherLabelerClient(baseUrl?: string): OllamaTeacherLabelerClient;
 export declare function createOllamaTeacherLabeler(config: AsyncTeacherOllamaLabelerConfigV1): TeacherLabeler;
+export declare function summarizeTeacherLabelerOpportunity(input: TeacherLabelerOpportunityInputV1, config?: AsyncTeacherLabelerConfigV1 | null): TeacherLabelerOpportunityV1;
 export declare function createTeacherLabeler(config: AsyncTeacherLabelerConfigV1 | null | undefined): TeacherLabeler | null;

package/dist/src/teacher-labeler.js

@@ -246,6 +246,48 @@ function normalizeOllamaTeacherLabelerConfig(config) {
         client: config.client ?? createHttpOllamaTeacherLabelerClient(normalizeBaseUrl(config.baseUrl))
     };
 }
+export function summarizeTeacherLabelerOpportunity(input, config) {
+    const normalized = config === undefined || config === null || config.provider === "none"
+        ? {
+            enabled: false,
+            maxPromptChars: DEFAULT_OLLAMA_MAX_PROMPT_CHARS,
+            maxArtifactsPerExport: DEFAULT_OLLAMA_MAX_ARTIFACTS_PER_EXPORT,
+            maxInteractionsPerExport: DEFAULT_OLLAMA_MAX_INTERACTIONS,
+            maxUserMessageChars: DEFAULT_OLLAMA_MAX_USER_MESSAGE_CHARS,
+            maxContextIdsPerDecision: DEFAULT_OLLAMA_MAX_CONTEXT_IDS
+        }
+        : {
+            enabled: true,
+            ...normalizeOllamaTeacherLabelerConfig(config)
+        };
+    const candidates = collectCandidates(input, normalized);
+    if (candidates.length === 0) {
+        return {
+            enabled: normalized.enabled,
+            candidateCount: 0,
+            budgetedCandidateCount: 0,
+            status: normalized.enabled ? "skipped" : "disabled",
+            detail: "no_matching_interaction_text"
+        };
+    }
+    const budgetedCandidates = fitCandidatesToPromptBudget(candidates, normalized);
+    if (budgetedCandidates.length === 0) {
+        return {
+            enabled: normalized.enabled,
+            candidateCount: candidates.length,
+            budgetedCandidateCount: 0,
+            status: normalized.enabled ? "skipped" : "disabled",
+            detail: "prompt_budget_exhausted"
+        };
+    }
+    return {
+        enabled: normalized.enabled,
+        candidateCount: candidates.length,
+        budgetedCandidateCount: budgetedCandidates.length,
+        status: normalized.enabled ? "ready" : "disabled",
+        detail: `candidates=${budgetedCandidates.length}`
+    };
+}
 class HttpOllamaTeacherLabelerClient {
     baseUrl;
     constructor(baseUrl) {

package/package.json

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