@openclawbrain/cli 0.4.14 → 0.4.16

package/dist/src/proof-command.js

@@ -255,6 +255,134 @@ function extractStatusSignals(statusText) {
         proofError: statusText.match(/proofError=([^\s]+)/)?.[1] ?? null,
     };
 }
+function extractDetailedStatusLine(statusText, prefix) {
+    const normalizedPrefix = `${prefix} `;
+    return statusText.split(/\r?\n/).find((line) => line.startsWith(normalizedPrefix)) ?? null;
+}
+function extractKeyValuePairs(line) {
+    if (typeof line !== "string") {
+        return {};
+    }
+    const pairs = {};
+    for (const match of line.matchAll(/([A-Za-z][A-Za-z0-9]*)=([^\s]+)/g)) {
+        pairs[match[1]] = match[2];
+    }
+    return pairs;
+}
+function extractAttachedProfileCoverageEntries(line) {
+    if (typeof line !== "string") {
+        return [];
+    }
+    const normalized = line.replace(/^attachedSet\s+/, "");
+    const proofPathIndex = normalized.indexOf(" proofPath=");
+    const entriesText = (proofPathIndex === -1 ? normalized : normalized.slice(0, proofPathIndex)).trim();
+    if (entriesText.length === 0 || entriesText === "none") {
+        return [];
+    }
+    const entries = [];
+    let index = 0;
+    while (index < entriesText.length) {
+        while (index < entriesText.length && entriesText[index] === " ") {
+            index += 1;
+        }
+        if (index >= entriesText.length) {
+            break;
+        }
+        const bracketStart = entriesText.indexOf("[", index);
+        if (bracketStart === -1) {
+            break;
+        }
+        const bracketEnd = entriesText.indexOf("]", bracketStart + 1);
+        if (bracketEnd === -1) {
+            break;
+        }
+        const rawLabel = entriesText.slice(index, bracketStart).trim();
+        const fields = extractKeyValuePairs(entriesText.slice(bracketStart + 1, bracketEnd));
+        entries.push({
+            label: rawLabel.replace(/^\*/, "").trim(),
+            current: rawLabel.startsWith("*"),
+            hookFiles: fields.hook ?? "unknown",
+            configLoad: fields.config ?? "unknown",
+            runtimeLoad: fields.runtime ?? "unknown",
+            loadedAt: fields.loadedAt ?? null,
+            coverageState: fields.hook === "present" && fields.config === "allows_load" && fields.runtime === "proven"
+                ? "covered"
+                : "attention"
+        });
+        index = bracketEnd + 1;
+    }
+    return entries;
+}
+function buildCoverageSnapshot({ attachedSetLine, runtimeLoadProofSnapshot, openclawHome }) {
+    const parsedEntries = extractAttachedProfileCoverageEntries(attachedSetLine);
+    const proofProfiles = Array.isArray(runtimeLoadProofSnapshot?.value?.profiles)
+        ? runtimeLoadProofSnapshot.value.profiles
+        : [];
+    const profiles = parsedEntries.length > 0
+        ? parsedEntries
+        : proofProfiles.map((profile) => ({
+            label: `${profile?.profileId ?? "current_profile"}@${canonicalizeExistingProofPath(profile?.openclawHome ?? "")}`,
+            current: canonicalizeExistingProofPath(profile?.openclawHome ?? "") === canonicalizeExistingProofPath(openclawHome),
+            hookFiles: "unknown",
+            configLoad: "unknown",
+            runtimeLoad: "proven",
+            loadedAt: profile?.loadedAt ?? null,
+            coverageState: "covered"
+        }));
+    const runtimeProvenCount = profiles.filter((entry) => entry.runtimeLoad === "proven").length;
+    return {
+        contract: "openclaw_operator_profile_coverage_snapshot.v1",
+        generatedAt: new Date().toISOString(),
+        openclawHome: canonicalizeExistingProofPath(openclawHome),
+        attachedProfileCount: profiles.length,
+        runtimeProofProfileCount: proofProfiles.length,
+        hookReadyCount: profiles.filter((entry) => entry.hookFiles === "present").length,
+        configReadyCount: profiles.filter((entry) => entry.configLoad === "allows_load").length,
+        runtimeProvenCount,
+        coverageRate: profiles.length === 0 ? null : runtimeProvenCount / profiles.length,
+        profiles
+    };
+}
+function buildHardeningSnapshot({ attachTruthLine, serveLine, routeFnLine, verdict, statusSignals }) {
+    const attachTruth = extractKeyValuePairs(attachTruthLine);
+    const serve = extractKeyValuePairs(serveLine);
+    const routeFn = extractKeyValuePairs(routeFnLine);
+    return {
+        contract: "openclaw_operator_hardening_snapshot.v1",
+        generatedAt: new Date().toISOString(),
+        statusSignals: {
+            statusOk: statusSignals.statusOk,
+            loadProofReady: statusSignals.loadProofReady,
+            runtimeProven: statusSignals.runtimeProven,
+            serveActivePack: statusSignals.serveActivePack,
+            routeFnAvailable: statusSignals.routeFnAvailable,
+        },
+        attachTruth: {
+            current: attachTruth.current ?? null,
+            hook: attachTruth.hook ?? null,
+            config: attachTruth.config ?? null,
+            runtime: attachTruth.runtime ?? null,
+            watcher: attachTruth.watcher ?? null,
+        },
+        serve: {
+            state: serve.state ?? null,
+            failOpen: serve.failOpen ?? null,
+            hardFail: serve.hardFail ?? null,
+            usedRouteFn: serve.usedRouteFn ?? null,
+            awaitingFirstExport: serve.awaitingFirstExport ?? null,
+        },
+        routeFn: {
+            available: routeFn.available ?? null,
+            freshness: routeFn.freshness ?? null,
+        },
+        verdict: {
+            verdict: verdict.verdict,
+            severity: verdict.severity,
+            missingProofCount: Array.isArray(verdict.missingProofs) ? verdict.missingProofs.length : 0,
+            warningCount: Array.isArray(verdict.warnings) ? verdict.warnings.length : 0,
+        }
+    };
+}
 
 function hasPackagedHookSource(pluginInspectText) {
     return /Source:\s+.*(?:@openclawbrain[\\/]+openclaw|openclawbrain)[\\/]+dist[\\/]+extension[\\/]+index\.js/m.test(pluginInspectText);
@@ -270,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)
@@ -282,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");
@@ -357,7 +496,7 @@ function buildVerdict({ steps, gatewayStatus, pluginInspect, statusSignals, brea
     };
 }
 
-function buildSummary({ options, steps, verdict, gatewayStatusText, pluginInspectText, statusSignals, breadcrumbs, runtimeLoadProofSnapshot }) {
+function buildSummary({ options, steps, verdict, gatewayStatusText, pluginInspectText, statusSignals, breadcrumbs, runtimeLoadProofSnapshot, guardLine, attributionLine, learningPathLine, coverageSnapshot, hardeningSnapshot }) {
     const passed = [];
     const missing = [];
     const warnings = Array.isArray(verdict.warnings) ? verdict.warnings : [];
@@ -413,6 +552,33 @@ function buildSummary({ options, steps, verdict, gatewayStatusText, pluginInspec
         "## Warnings",
         ...(warnings.length === 0 ? ["- none"] : warnings.map((item) => `- ${item}`)),
         "",
+        "## Runtime Guard",
+        ...(guardLine === null
+            ? ["- runtime guard line not reported by detailed status"]
+            : [`- ${guardLine}`]),
+        "",
+        "## Learning Attribution",
+        ...(attributionLine === null
+            ? ["- attribution line not reported by detailed status"]
+            : [`- ${attributionLine}`]),
+        ...(learningPathLine === null
+            ? []
+            : [`- ${learningPathLine}`]),
+        "",
+        "## Coverage snapshot",
+        `- attached profiles: ${coverageSnapshot.attachedProfileCount}`,
+        `- runtime-proven profiles: ${coverageSnapshot.runtimeProvenCount}/${coverageSnapshot.attachedProfileCount}`,
+        `- coverage rate: ${coverageSnapshot.coverageRate === null ? "none" : coverageSnapshot.coverageRate.toFixed(3)}`,
+        ...(coverageSnapshot.profiles.length === 0
+            ? ["- per-profile: none"]
+            : coverageSnapshot.profiles.map((entry) => `- ${entry.current ? "*" : ""}${entry.label} coverage=${entry.coverageState} hook=${entry.hookFiles} config=${entry.configLoad} runtime=${entry.runtimeLoad} loadedAt=${entry.loadedAt ?? "none"}`)),
+        "",
+        "## Hardening snapshot",
+        `- status signals: statusOk=${hardeningSnapshot.statusSignals.statusOk} loadProofReady=${hardeningSnapshot.statusSignals.loadProofReady} runtimeProven=${hardeningSnapshot.statusSignals.runtimeProven} serveActivePack=${hardeningSnapshot.statusSignals.serveActivePack} routeFnAvailable=${hardeningSnapshot.statusSignals.routeFnAvailable}`,
+        `- serve: state=${hardeningSnapshot.serve.state ?? "none"} failOpen=${hardeningSnapshot.serve.failOpen ?? "none"} hardFail=${hardeningSnapshot.serve.hardFail ?? "none"} usedRouteFn=${hardeningSnapshot.serve.usedRouteFn ?? "none"}`,
+        `- attachTruth: current=${hardeningSnapshot.attachTruth.current ?? "none"} hook=${hardeningSnapshot.attachTruth.hook ?? "none"} config=${hardeningSnapshot.attachTruth.config ?? "none"} runtime=${hardeningSnapshot.attachTruth.runtime ?? "none"}`,
+        `- proof verdict: ${hardeningSnapshot.verdict.verdict} severity=${hardeningSnapshot.verdict.severity} warnings=${hardeningSnapshot.verdict.warningCount}`,
+        "",
         "## Step ledger",
         ...steps.map((step) => `- ${step.stepId}: ${step.skipped ? "skipped" : `${step.resultClass} (${step.captureState})`} - ${step.summary}`),
     ];
@@ -442,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))}`;
 }
@@ -454,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",
@@ -469,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;
@@ -526,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) {
@@ -550,6 +749,8 @@ export function parseProofCliArgs(argv, options = {}) {
             skipInstall,
             skipRestart,
             pluginId,
+            gatewayUrl,
+            gatewayToken,
             timeoutMs,
             json,
             help
@@ -570,6 +771,8 @@ export function parseProofCliArgs(argv, options = {}) {
         skipInstall,
         skipRestart,
         pluginId,
+        gatewayUrl,
+        gatewayToken,
         timeoutMs,
         json,
         help
@@ -628,21 +831,38 @@ 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);
     const activationRoot = extractActivationRoot(statusCapture.stdout, options.activationRoot ?? null);
     const statusSignals = extractStatusSignals(statusCapture.stdout);
+    const attachTruthLine = extractDetailedStatusLine(statusCapture.stdout, "attachTruth");
+    const attachedSetLine = extractDetailedStatusLine(statusCapture.stdout, "attachedSet");
+    const serveLine = extractDetailedStatusLine(statusCapture.stdout, "serve");
+    const routeFnLine = extractDetailedStatusLine(statusCapture.stdout, "routeFn");
+    const guardLine = extractDetailedStatusLine(statusCapture.stdout, "guard");
+    const attributionLine = extractDetailedStatusLine(statusCapture.stdout, "attribution");
+    const learningPathLine = extractDetailedStatusLine(statusCapture.stdout, "path");
     const runtimeLoadProofPath = normalizeReportedProofPath(statusSignals.proofPath)
         ?? path.join(activationRoot, "attachment-truth", "runtime-load-proofs.json");
     const runtimeLoadProofSnapshot = readJsonSnapshot(runtimeLoadProofPath);
     const gatewayLogText = readTextIfExists(gatewayLogPath);
     const breadcrumbs = extractStartupBreadcrumbs(gatewayLogText, bundleStartedAt);
+    const coverageSnapshot = buildCoverageSnapshot({
+        attachedSetLine,
+        runtimeLoadProofSnapshot,
+        openclawHome: options.openclawHome,
+    });
     writeText(path.join(bundleDir, "extracted-startup-breadcrumbs.log"), breadcrumbs.all.length === 0
         ? "<no matching breadcrumbs found>\n"
         : `${breadcrumbs.all.map((entry) => entry.line).join("\n")}\n`);
     writeJson(path.join(bundleDir, "runtime-load-proof.json"), runtimeLoadProofSnapshot);
+    writeJson(path.join(bundleDir, "coverage-snapshot.json"), coverageSnapshot);
     const verdict = buildVerdict({
         steps,
         gatewayStatus: gatewayStatusCapture.stdout,
@@ -652,6 +872,13 @@ export function captureOperatorProofBundle(options) {
         runtimeLoadProofSnapshot,
         openclawHome: options.openclawHome,
     });
+    const hardeningSnapshot = buildHardeningSnapshot({
+        attachTruthLine,
+        serveLine,
+        routeFnLine,
+        verdict,
+        statusSignals,
+    });
     writeJson(path.join(bundleDir, "steps.json"), {
         bundleStartedAt,
         openclawHome: canonicalizeExistingProofPath(options.openclawHome),
@@ -664,6 +891,8 @@ export function captureOperatorProofBundle(options) {
         bundleStartedAt,
         verdict,
         statusSignals,
+        coverageSnapshot,
+        hardeningSnapshot,
         breadcrumbs: {
             allCount: breadcrumbs.all.length,
             postBundleCount: breadcrumbs.afterBundleStart.length,
@@ -671,7 +900,11 @@ export function captureOperatorProofBundle(options) {
         },
         runtimeLoadProofPath,
         runtimeLoadProofError: runtimeLoadProofSnapshot.error,
+        guardLine,
+        attributionLine,
+        learningPathLine,
     });
+    writeJson(path.join(bundleDir, "hardening-snapshot.json"), hardeningSnapshot);
     writeText(path.join(bundleDir, "summary.md"), buildSummary({
         options,
         steps,
@@ -681,6 +914,11 @@ export function captureOperatorProofBundle(options) {
         statusSignals,
         breadcrumbs,
         runtimeLoadProofSnapshot,
+        guardLine,
+        attributionLine,
+        learningPathLine,
+        coverageSnapshot,
+        hardeningSnapshot,
     }));
     return {
         ok: true,
@@ -691,14 +929,21 @@ export function captureOperatorProofBundle(options) {
         gatewayLogPath,
         runtimeLoadProofPath,
         runtimeLoadProofSnapshot,
+        coverageSnapshot,
+        hardeningSnapshot,
         verdict,
         statusSignals,
+        guardLine,
+        attributionLine,
+        learningPathLine,
         steps,
         summaryPath: path.join(bundleDir, "summary.md"),
         stepsPath: path.join(bundleDir, "steps.json"),
         verdictPath: path.join(bundleDir, "verdict.json"),
         breadcrumbPath: path.join(bundleDir, "extracted-startup-breadcrumbs.log"),
         runtimeLoadProofSnapshotPath: path.join(bundleDir, "runtime-load-proof.json"),
+        coverageSnapshotPath: path.join(bundleDir, "coverage-snapshot.json"),
+        hardeningSnapshotPath: path.join(bundleDir, "hardening-snapshot.json"),
     };
 }
 
@@ -713,6 +958,8 @@ export function formatOperatorProofResult(result) {
         `  Verdict: ${result.verdictPath}`,
         `  Breadcrumbs: ${result.breadcrumbPath}`,
         `  Runtime proof: ${result.runtimeLoadProofSnapshotPath}`,
+        `  Coverage snapshot: ${result.coverageSnapshotPath}`,
+        `  Hardening snapshot: ${result.hardeningSnapshotPath}`,
     ];
     return lines.join("\n");
 }

package/dist/src/runtime-core.js

@@ -39,8 +39,75 @@ function normalizeNonNegativeInteger(value, fieldName, fallbackValue) {
   return value;
 }
 
-function normalizeMode(value) {
-  return value ?? "heuristic";
+const RUNTIME_COMPARATIVE_REPLAY_MODE_CONFIG = {
+  vector_only: {
+    routeMode: "heuristic",
+    selectionMode: "flat_rank_v1",
+  },
+  graph_prior_only: {
+    routeMode: "heuristic",
+    selectionMode: "graph_walk_v1",
+  },
+  learned_route: {
+    routeMode: "learned",
+    selectionMode: "graph_walk_v1",
+  },
+};
+
+function resolveRuntimeComparativeReplayMode(value) {
+  return Object.prototype.hasOwnProperty.call(RUNTIME_COMPARATIVE_REPLAY_MODE_CONFIG, value)
+    ? value
+    : null;
+}
+
+function resolveCompileModePlan(modeValue, selectionModeValue) {
+  const requestedSelectionMode = normalizeCompileSelectionMode(selectionModeValue);
+  const comparativeMode = resolveRuntimeComparativeReplayMode(modeValue);
+
+  if (comparativeMode === null) {
+    if (modeValue === undefined) {
+      return {
+        comparativeMode: null,
+        routeMode: "heuristic",
+        selectionMode: requestedSelectionMode,
+      };
+    }
+
+    if (modeValue === "heuristic" || modeValue === "learned") {
+      return {
+        comparativeMode: null,
+        routeMode: modeValue,
+        selectionMode: requestedSelectionMode,
+      };
+    }
+
+    throw new Error(
+      "mode must be heuristic, learned, vector_only, graph_prior_only, or learned_route",
+    );
+  }
+
+  const plan = RUNTIME_COMPARATIVE_REPLAY_MODE_CONFIG[comparativeMode];
+
+  if (requestedSelectionMode !== undefined && requestedSelectionMode !== plan.selectionMode) {
+    throw new Error(
+      `selectionMode ${requestedSelectionMode} conflicts with comparative mode ${comparativeMode}, expected ${plan.selectionMode}`,
+    );
+  }
+
+  return {
+    comparativeMode,
+    routeMode: plan.routeMode,
+    selectionMode: plan.selectionMode,
+  };
+}
+
+function resolveSyntheticTurnMode(value) {
+  const comparativeMode = resolveRuntimeComparativeReplayMode(value);
+  if (comparativeMode !== null) {
+    return RUNTIME_COMPARATIVE_REPLAY_MODE_CONFIG[comparativeMode].routeMode;
+  }
+
+  return value === "heuristic" || value === "learned" ? value : undefined;
 }
 
 function normalizeCompileSelectionMode(value) {
@@ -83,7 +150,7 @@ function formatPromptContext(compileResponse) {
   }
 
   for (const block of compileResponse.selectedContext) {
-    lines.push(`SOURCE: ${block.source}`);
+    lines.push(`PROVENANCE_REF: ctx_${block.id}`);
     lines.push(`BLOCK_ID: ${block.id}`);
     lines.push(block.text.trim());
     lines.push("");
@@ -273,8 +340,10 @@ function appendCompileServeRouteDecisionLog(input) {
     syntheticTurn.budgetStrategy = input.compileInput.budgetStrategy;
   }
 
-  if (input.compileInput.mode === "heuristic" || input.compileInput.mode === "learned") {
-    syntheticTurn.mode = input.compileInput.mode;
+  const syntheticTurnMode = resolveSyntheticTurnMode(input.compileInput.mode);
+
+  if (syntheticTurnMode !== undefined) {
+    syntheticTurn.mode = syntheticTurnMode;
   }
 
   if (input.compileInput.runtimeHints !== undefined) {
@@ -456,6 +525,7 @@ export function compileRuntimeContext(input) {
   let activationRoot = fallbackActivationRoot;
   let agentId = process.env.OPENCLAWBRAIN_AGENT_ID ?? DEFAULT_AGENT_ID;
   let runtimeHints = [];
+  let comparativeMode = null;
   let selectionMode;
   let userMessage = "";
   let maxContextChars;
@@ -470,13 +540,15 @@ export function compileRuntimeContext(input) {
     activationRoot = path.resolve(normalizeNonEmptyString(input.activationRoot, "activationRoot"));
     agentId = normalizeOptionalString(input.agentId) ?? process.env.OPENCLAWBRAIN_AGENT_ID ?? DEFAULT_AGENT_ID;
     runtimeHints = normalizeRuntimeHints(input.runtimeHints);
-    selectionMode = normalizeCompileSelectionMode(input.selectionMode);
     userMessage = normalizeNonEmptyString(input.message, "message");
     maxContextChars =
       input.maxContextChars !== undefined
         ? normalizeNonNegativeInteger(input.maxContextChars, "maxContextChars", input.maxContextChars)
         : undefined;
-    mode = normalizeMode(input.mode);
+    const compileModePlan = resolveCompileModePlan(input.mode, input.selectionMode);
+    comparativeMode = compileModePlan.comparativeMode;
+    mode = compileModePlan.routeMode;
+    selectionMode = compileModePlan.selectionMode;
   } catch (error) {
     result = failOpenCompileResult(
       error,
@@ -518,6 +590,7 @@ export function compileRuntimeContext(input) {
       },
     );
     routeSelectionMs = elapsedMsFrom(routeSelectionStartedAtNs);
+    const selectionEngine = selectionMode ?? "flat_rank_v1";
     const compileResponse = {
       ...compile.response,
       diagnostics: {
@@ -525,6 +598,13 @@ export function compileRuntimeContext(input) {
         notes: uniqueNotes([
           ...compile.response.diagnostics.notes,
           ...resolvedBudget.notes,
+          `selection_engine=${selectionEngine}`,
+          ...(comparativeMode === null
+            ? []
+            : [
+                `comparative_mode=${comparativeMode}`,
+                `comparative_mode_plan=${mode}+${selectionEngine}`,
+              ]),
           "OpenClaw remains the runtime owner",
         ]),
       },

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

@@ -7,14 +7,43 @@ function isSeedAwaitingFirstPromotion(status) {
 function normalizeOptionalString(value) {
     return typeof value === "string" && value.trim().length > 0 ? value : null;
 }
+function formatOperatorLearningAttributionSummary({ status }) {
+    const attribution = status?.learningAttribution ?? null;
+    if (!attribution) {
+        return "quality=unavailable source=unavailable detail=no_learning_attribution_surface";
+    }
+    const source = [normalizeOptionalString(attribution.source), normalizeOptionalString(attribution.snapshotKind)]
+        .filter((value) => value !== null)
+        .join("/");
+    if (attribution.available !== true) {
+        return `quality=${normalizeOptionalString(attribution.quality) ?? "unavailable"} source=${source || "unavailable"} detail=${normalizeOptionalString(attribution.detail) ?? "unavailable"}`;
+    }
+    const matchedByMode = attribution.matchedByMode ?? {};
+    return [
+        `quality=${normalizeOptionalString(attribution.quality) ?? "unavailable"}`,
+        `source=${source || "latest_materialization"}`,
+        `nonZero=${attribution.nonZeroObservationCount ?? 0}`,
+        `exact=${attribution.exactMatchCount ?? 0}`,
+        `heuristic=${attribution.heuristicMatchCount ?? 0}`,
+        `unmatched=${attribution.unmatchedCount ?? 0}`,
+        `ambiguous=${attribution.ambiguousCount ?? 0}`,
+        `modes=decision:${matchedByMode.exactDecisionId ?? 0}|digest:${matchedByMode.exactSelectionDigest ?? 0}|compile:${matchedByMode.turnCompileEventId ?? 0}|heuristic:${matchedByMode.legacyHeuristic ?? 0}`
+    ].join(" ");
+}
 export function formatOperatorLearningPathSummary({ status, learningPath, tracedLearning }) {
+    const attribution = status?.learningAttribution ?? null;
     if (!isSeedAwaitingFirstPromotion(status)) {
-        return formatRawLearningPathSummary(learningPath);
+        const rawSummary = formatRawLearningPathSummary(learningPath);
+        const bindingQuality = normalizeOptionalString(attribution?.quality);
+        return bindingQuality === null || bindingQuality === "unavailable"
+            ? rawSummary
+            : `${rawSummary} bindingQuality=${bindingQuality}`;
     }
     const detailParts = [
         "detail=seed_state_awaiting_first_promotion",
         `tracedPg=${normalizeOptionalString(tracedLearning?.pgVersionUsed) ?? "none"}`,
-        `tracedPack=${normalizeOptionalString(tracedLearning?.materializedPackId) ?? "none"}`
+        `tracedPack=${normalizeOptionalString(tracedLearning?.materializedPackId) ?? "none"}`,
+        `bindingQuality=${normalizeOptionalString(attribution?.quality) ?? "unavailable"}`
     ];
     return [
         "source=seed_state",
@@ -26,3 +55,4 @@ export function formatOperatorLearningPathSummary({ status, learningPath, traced
         ...detailParts
     ].join(" ");
 }
+export { formatOperatorLearningAttributionSummary };