@openclawbrain/cli 0.4.14 → 0.4.16

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/learning-spine.js

@@ -23,6 +23,48 @@ function softmax(values) {
     }
     return numerators.map((value) => roundNumber(value / denominator));
 }
+function isPlainObject(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function compactStructuralSignalValue(value, depth = 0) {
+    if (value === null || typeof value === "boolean") {
+        return value;
+    }
+    if (typeof value === "number") {
+        return Number.isFinite(value) ? roundNumber(value) : undefined;
+    }
+    if (typeof value === "string") {
+        return value.length <= 256 ? value : `${value.slice(0, 256)}...`;
+    }
+    if (depth >= 3) {
+        return undefined;
+    }
+    if (Array.isArray(value)) {
+        const compacted = value
+            .slice(0, 32)
+            .map((entry) => compactStructuralSignalValue(entry, depth + 1))
+            .filter((entry) => entry !== undefined);
+        return compacted;
+    }
+    if (!isPlainObject(value)) {
+        return undefined;
+    }
+    const compactedEntries = Object.entries(value)
+        .slice(0, 32)
+        .flatMap(([key, entry]) => {
+        const compacted = compactStructuralSignalValue(entry, depth + 1);
+        return compacted === undefined ? [] : [[key, compacted]];
+    });
+    return compactedEntries.length > 0 ? Object.fromEntries(compactedEntries) : undefined;
+}
+function compactStructuralSignals(value) {
+    const compacted = compactStructuralSignalValue(value);
+    return compacted !== undefined && isPlainObject(compacted) ? compacted : null;
+}
 function isStableKernelContextBlock(block) {
     if (block.id.includes(":event:") || block.id.includes(":teacher:")) {
         return false;
@@ -264,7 +306,7 @@ export function appendServeTimeRouteDecisionLog(input) {
             actionScore: roundNumber(entry.score),
             actionProbability: probabilities[index] ?? 0
         })),
-        structuralSignals: null,
+        structuralSignals: compactStructuralSignals(input.compileResult.ok ? input.compileResult.compileResponse.structuralSignals : null),
         fallbackReason: serveFallbackReason(input.compileResult),
         hotPathTiming: input.compileResult.timing,
         kernelContextCount: selectedKernelContextIds.length,

package/dist/src/local-learner.d.ts

@@ -85,6 +85,12 @@ export interface TeacherObservationBindingStatsV1 {
     totalObservationCount: number;
     nonZeroObservationCount: number;
     skippedZeroRewardCount: number;
+    accounting: {
+        exact: number;
+        heuristic: number;
+        unmatched: number;
+        ambiguous: number;
+    };
     matched: {
         exactDecisionId: number;
         exactSelectionDigest: number;

package/dist/src/local-learner.js

@@ -3,9 +3,10 @@ import path from "node:path";
 import { DatabaseSync } from "node:sqlite";
 import { buildRouteArtifactReference, CONTRACT_IDS, PACK_GRAPH_SCHEMAS, ROUTER_PG_PROFILE_V1, ROUTER_PG_PROFILE_V2, checksumJsonPayload, computeRouterCollectedLabelCounts, computeRouterFreshnessChecksum, computeRouterObjectiveChecksum, computeRouterQueryChecksum, computeRouterWeightsChecksum, sortNormalizedEvents, validateTeacherSupervisionArtifact } from "@openclawbrain/contracts";
 import { buildNormalizedEventDedupId, buildNormalizedEventExport, buildNormalizedEventExportBridge, createDefaultLearningSurface, createEventExportCursor, createExplicitEventRange, validateNormalizedEventExport, validateNormalizedEventExportBridge, validateNormalizedEventExportSlice } from "@openclawbrain/event-export";
-import { computePayloadChecksum, loadPack, PACK_LAYOUT, summarizeStructuralGraphEvolution, writePackFile } from "@openclawbrain/pack-format";
+import { computePayloadChecksum, loadPack, loadPackFromActivation, PACK_LAYOUT, summarizeStructuralGraphEvolution, writePackFile } from "@openclawbrain/pack-format";
 import { buildArtifactProvenance } from "@openclawbrain/provenance";
 import { createWorkspaceMetadata } from "@openclawbrain/workspace-metadata";
+import { createServeTimeDecisionMatcher } from "./teacher-decision-match.js";
 export const DEFAULT_ALWAYS_ON_LEARNING_LIVE_SLICES_PER_CYCLE = 1;
 export const DEFAULT_ALWAYS_ON_LEARNING_BACKFILL_SLICES_PER_CYCLE = 1;
 export const DEFAULT_TEACHER_SUPERVISION_STALE_AFTER_MS = 5 * 60 * 1_000;
@@ -26,6 +27,7 @@ export const ALWAYS_ON_STRUCTURAL_PLASTICITY_OP_CEILING = {
 export const ALWAYS_ON_STRUCTURAL_PLASTICITY_MIN_INTERACTIONS = 2;
 export const ALWAYS_ON_STRUCTURAL_PLASTICITY_MIN_FEEDBACK = 1;
 const CONNECT_PAIR_SCORE_THRESHOLD = 2;
+const MAX_CARRY_FORWARD_SEED_BLOCKS = 12;
 export const DEFAULT_SPARSE_FEEDBACK_POLICY = {
     teacherBudget: 32,
     teacherDelayMs: 0,
@@ -4254,6 +4256,12 @@ function emptyTeacherObservationBindingStats() {
         totalObservationCount: 0,
         nonZeroObservationCount: 0,
         skippedZeroRewardCount: 0,
+        accounting: {
+            exact: 0,
+            heuristic: 0,
+            unmatched: 0,
+            ambiguous: 0
+        },
         matched: {
             exactDecisionId: 0,
             exactSelectionDigest: 0,
@@ -4276,6 +4284,7 @@ function emptyTeacherObservationBindingStats() {
 }
 function summarizeTeacherObservationBindingStats(stats) {
     return [
+        `accounting(exact=${stats.accounting.exact},heuristic=${stats.accounting.heuristic},unmatched=${stats.accounting.unmatched},ambiguous=${stats.accounting.ambiguous})`,
         `matched(exact_decision_id=${stats.matched.exactDecisionId},exact_selection_digest=${stats.matched.exactSelectionDigest},turn_compile_event_id=${stats.matched.turnCompileEventId},legacy_heuristic=${stats.matched.legacyHeuristic})`,
         `unmatched(exact_decision_id=${stats.unmatched.exactDecisionId},exact_selection_digest=${stats.unmatched.exactSelectionDigest},turn_compile_event_id=${stats.unmatched.turnCompileEventId},legacy_heuristic=${stats.unmatched.legacyHeuristic})`,
         `ambiguous(exact_decision_id=${stats.ambiguous.exactDecisionId},exact_selection_digest=${stats.ambiguous.exactSelectionDigest},turn_compile_event_id=${stats.ambiguous.turnCompileEventId},legacy_heuristic=${stats.ambiguous.legacyHeuristic})`,
@@ -4365,8 +4374,7 @@ function resolveTeacherObservationDecisionMatch(decisions, observation, indexes)
             ? { kind: "unmatched", mode: "exactSelectionDigest" }
             : { kind: "matched", mode: "exactSelectionDigest", decision };
     }
-    if (normalizeObservationOptionalString(observation.selectionDigest) !== null
-        || normalizeObservationOptionalString(observation.activePackGraphChecksum) !== null) {
+    if (normalizeObservationOptionalString(observation.selectionDigest) !== null) {
         return { kind: "unmatched", mode: "exactSelectionDigest" };
     }
     const turnCompileEventId = normalizeObservationOptionalString(observation.turnCompileEventId);
@@ -4401,13 +4409,21 @@ function joinDecisionsWithTeacherObservationOutcomes(decisions, observationOutco
         stats.nonZeroObservationCount += 1;
         const match = resolveTeacherObservationDecisionMatch(decisions, observation, indexes);
         if (match.kind === "unmatched") {
+            stats.accounting.unmatched += 1;
             stats.unmatched[match.mode] += 1;
             continue;
         }
         if (match.kind === "ambiguous") {
+            stats.accounting.ambiguous += 1;
             stats.ambiguous[match.mode] += 1;
             continue;
         }
+        if (match.mode === "legacyHeuristic") {
+            stats.accounting.heuristic += 1;
+        }
+        else {
+            stats.accounting.exact += 1;
+        }
         stats.matched[match.mode] += 1;
         const current = outcomes.get(match.decision.recordId) ?? 0;
         if (current === 0 || Math.abs(reward) > Math.abs(current)) {
@@ -4426,149 +4442,7 @@ export function joinDecisionsWithFeedback(decisions, eventExport, maxDelayMs = 3
         return outcomes;
     }
     const normalizeOptionalString = (value) => typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
-    const toTimestamp = (value) => {
-        const normalized = normalizeOptionalString(value);
-        if (normalized === undefined) {
-            return null;
-        }
-        const parsed = Date.parse(normalized);
-        return Number.isFinite(parsed) ? parsed : null;
-    };
-    const buildSessionChannelKey = (sessionId, channel) => {
-        const normalizedSessionId = normalizeOptionalString(sessionId);
-        const normalizedChannel = normalizeOptionalString(channel);
-        if (normalizedSessionId === undefined || normalizedChannel === undefined) {
-            return null;
-        }
-        return `${normalizedSessionId}|${normalizedChannel}`;
-    };
-    const buildCandidateKey = (sessionId, channel, createdAt) => {
-        const sessionChannelKey = buildSessionChannelKey(sessionId, channel);
-        const normalizedCreatedAt = normalizeOptionalString(createdAt);
-        if (sessionChannelKey === null || normalizedCreatedAt === undefined) {
-            return null;
-        }
-        return `${sessionChannelKey}|${normalizedCreatedAt}`;
-    };
-    const buildDecisionTimestamps = (decision) => {
-        const timestamps = [];
-        const turnCreatedAt = toTimestamp(decision.turnCreatedAt);
-        const recordedAt = toTimestamp(decision.recordedAt);
-        if (turnCreatedAt !== null) {
-            timestamps.push(turnCreatedAt);
-        }
-        if (recordedAt !== null && !timestamps.includes(recordedAt)) {
-            timestamps.push(recordedAt);
-        }
-        return timestamps;
-    };
-    const operationalPatterns = [
-        /^NO_REPLY$/i,
-        /^HEARTBEAT_OK$/i,
-        /^read heartbeat\.md if it exists/i,
-        /^a new session was started via \/new or \/reset\./i,
-        /\[cron:[a-f0-9-]+\s/i,
-        /\[system message\]\s*\[sessionid:/i,
-    ];
-    const isOperationalDecision = (decision) => {
-        const userMessage = normalizeOptionalString(decision.userMessage);
-        if (userMessage === undefined) {
-            return true;
-        }
-        return operationalPatterns.some((pattern) => pattern.test(userMessage));
-    };
-    const selectNearestDecision = (entries, interactionAt) => {
-        const candidates = entries
-            .map((entry) => {
-                const deltas = entry.timestamps.map((timestamp) => Math.abs(timestamp - interactionAt));
-                const bestDelta = deltas.length === 0 ? null : Math.min(...deltas);
-                return bestDelta === null || bestDelta > maxDelayMs
-                    ? null
-                    : {
-                        decision: entry.decision,
-                        deltaMs: bestDelta,
-                        recordedAt: toTimestamp(entry.decision.recordedAt) ?? 0,
-                    };
-            })
-            .filter((entry) => entry !== null)
-            .sort((left, right) => {
-                if (left.deltaMs !== right.deltaMs) {
-                    return left.deltaMs - right.deltaMs;
-                }
-                return right.recordedAt - left.recordedAt;
-            });
-        const best = candidates[0] ?? null;
-        const runnerUp = candidates[1] ?? null;
-        if (best === null) {
-            return null;
-        }
-        if (runnerUp !== null && runnerUp.deltaMs === best.deltaMs && runnerUp.decision !== best.decision) {
-            return null;
-        }
-        return best.decision;
-    };
-    const exactDecisions = new Map();
-    const fallbackDecisions = new Map();
-    const decisionsBySessionChannel = new Map();
-    const globalFallbackDecisions = [];
-    for (const decision of [...decisions].sort((left, right) => Date.parse(right.recordedAt) - Date.parse(left.recordedAt))) {
-        const userMessage = normalizeOptionalString(decision.userMessage);
-        if (userMessage === undefined) {
-            continue;
-        }
-        const turnCompileEventId = normalizeOptionalString(decision.turnCompileEventId);
-        if (turnCompileEventId !== undefined && !exactDecisions.has(turnCompileEventId)) {
-            exactDecisions.set(turnCompileEventId, decision);
-        }
-        for (const candidateKey of [
-            buildCandidateKey(decision.sessionId, decision.channel, decision.turnCreatedAt),
-            buildCandidateKey(decision.sessionId, decision.channel, decision.recordedAt),
-        ]) {
-            if (candidateKey !== null && !fallbackDecisions.has(candidateKey)) {
-                fallbackDecisions.set(candidateKey, decision);
-            }
-        }
-        const sessionChannelKey = buildSessionChannelKey(decision.sessionId, decision.channel);
-        const indexedEntry = {
-            decision,
-            timestamps: buildDecisionTimestamps(decision),
-            operational: isOperationalDecision(decision),
-        };
-        if (sessionChannelKey !== null) {
-            const indexed = decisionsBySessionChannel.get(sessionChannelKey) ?? [];
-            indexed.push(indexedEntry);
-            decisionsBySessionChannel.set(sessionChannelKey, indexed);
-        }
-        if (!indexedEntry.operational) {
-            globalFallbackDecisions.push(indexedEntry);
-        }
-    }
-    const matchInteractionToDecision = (interaction) => {
-        const exact = exactDecisions.get(interaction.eventId);
-        if (exact !== undefined) {
-            return exact;
-        }
-        const exactFallbackKey = buildCandidateKey(interaction.sessionId, interaction.channel, interaction.createdAt);
-        if (exactFallbackKey !== null) {
-            const fallback = fallbackDecisions.get(exactFallbackKey);
-            if (fallback !== undefined) {
-                return fallback;
-            }
-        }
-        const interactionAt = toTimestamp(interaction.createdAt);
-        const sessionChannelKey = buildSessionChannelKey(interaction.sessionId, interaction.channel);
-        if (interactionAt === null) {
-            return null;
-        }
-        if (sessionChannelKey !== null) {
-            const sessionEntries = (decisionsBySessionChannel.get(sessionChannelKey) ?? []).filter((entry) => entry.operational !== true);
-            const sessionMatch = selectNearestDecision(sessionEntries, interactionAt);
-            if (sessionMatch !== null) {
-                return sessionMatch;
-            }
-        }
-        return selectNearestDecision(globalFallbackDecisions, interactionAt);
-    };
+    const matchInteractionToDecision = createServeTimeDecisionMatcher(decisions, { maxTimeDeltaMs: maxDelayMs });
     const interactionById = new Map();
     for (const interaction of eventExport.interactionEvents ?? []) {
         const interactionId = normalizeOptionalString(interaction.eventId);
@@ -4576,7 +4450,7 @@ export function joinDecisionsWithFeedback(decisions, eventExport, maxDelayMs = 3
             interactionById.set(interactionId, interaction);
         }
     }
-    const matchedFeedbackIds = new Set();
+    const consumedFeedbackIds = new Set();
     for (const event of eventExport.feedbackEvents ?? []) {
         const relatedInteractionId = normalizeOptionalString(event.relatedInteractionId);
         if (relatedInteractionId === undefined) {
@@ -4586,6 +4460,8 @@ export function joinDecisionsWithFeedback(decisions, eventExport, maxDelayMs = 3
         if (interaction === undefined) {
             continue;
         }
+        const feedbackId = normalizeOptionalString(event.eventId) ?? `${relatedInteractionId}|${normalizeOptionalString(event.createdAt) ?? 'unknown'}`;
+        consumedFeedbackIds.add(feedbackId);
         const matchedDecision = matchInteractionToDecision(interaction);
         if (matchedDecision === null) {
             continue;
@@ -4597,13 +4473,11 @@ export function joinDecisionsWithFeedback(decisions, eventExport, maxDelayMs = 3
                 outcomes.set(matchedDecision.recordId, reward);
             }
         }
-        const feedbackId = normalizeOptionalString(event.eventId) ?? `${relatedInteractionId}|${normalizeOptionalString(event.createdAt) ?? 'unknown'}`;
-        matchedFeedbackIds.add(feedbackId);
     }
     const feedbackBySession = new Map();
     for (const event of eventExport.feedbackEvents ?? []) {
         const feedbackId = normalizeOptionalString(event.eventId) ?? `${normalizeOptionalString(event.relatedInteractionId) ?? '__none__'}|${normalizeOptionalString(event.createdAt) ?? 'unknown'}`;
-        if (matchedFeedbackIds.has(feedbackId)) {
+        if (consumedFeedbackIds.has(feedbackId)) {
             continue;
         }
         const sessionId = event.sessionId ?? "__none__";
@@ -4972,6 +4846,57 @@ function defaultLearningSurface(workspace, offlineArtifacts, workspaceInit) {
         ...offlineArtifacts.map((artifact) => `offline:${artifact}`)
     ]));
 }
+function isCarryForwardSeedBlock(block) {
+    const role = block.learning?.role ?? "";
+    if (role !== "interaction" && role !== "feedback" && role !== "teacher_supervision" && role !== "label_surface") {
+        return false;
+    }
+    if (typeof block.text !== "string" || block.text.trim().length === 0) {
+        return false;
+    }
+    // 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) {
+    return (block.initSeed?.score ?? 0) +
+        (block.state?.strength ?? 0) +
+        (block.learning?.humanLabels ?? 0) * 2 +
+        (block.learning?.selfLabels ?? 0);
+}
+function loadCarryForwardSeedBlocksFromActivation(activationRoot, currentGraphBlockIds) {
+    try {
+        const activePack = loadPackFromActivation(activationRoot, "active", { requireActivationReady: true });
+        if (activePack === null) {
+            return [];
+        }
+        const candidates = activePack.graph.blocks
+            .filter((block) => isCarryForwardSeedBlock(block) && !currentGraphBlockIds.has(block.id));
+        const preferred = candidates.filter((block) => block.learning?.role !== "interaction");
+        const selected = (preferred.length > 0 ? preferred : candidates)
+            .sort((left, right) => carryForwardSeedBlockScore(right) - carryForwardSeedBlockScore(left) ||
+            right.priority - left.priority ||
+            left.id.localeCompare(right.id))
+            .slice(0, MAX_CARRY_FORWARD_SEED_BLOCKS);
+        if (selected.length === 0) {
+            return [];
+        }
+        const selectedIds = new Set(selected.map((block) => block.id));
+        return selected.map((block) => ({
+            ...structuredClone(block),
+            ...(block.edges === undefined
+                ? {}
+                : {
+                    edges: block.edges.filter((edge) => selectedIds.has(edge.targetBlockId))
+                })
+        }));
+    }
+    catch {
+        return [];
+    }
+}
 function cloneRuntimeGraphForPack(packId, runtimeGraph, builtAt) {
     const cloned = structuredClone(runtimeGraph);
     cloned.packId = packId;
@@ -5045,9 +4970,18 @@ function buildRuntimeGraphSnapshot(input) {
         rootDir: workspace.rootDir,
         observedAt: builtAt
     }));
+    const carryForwardSeedBlocks = input.activationRoot === undefined
+        ? []
+        : loadCarryForwardSeedBlocksFromActivation(input.activationRoot, new Set(graph.blocks.map((block) => block.id)));
+    const graphWithCarryForwardSeed = carryForwardSeedBlocks.length === 0
+        ? graph
+        : {
+            ...graph,
+            blocks: [...graph.blocks, ...carryForwardSeedBlocks]
+        };
     return {
-        graph,
-        plasticity: summarizeRuntimeGraphPlasticity("live_loop", graph, builtAt, null, normalizedEventExport)
+        graph: graphWithCarryForwardSeed,
+        plasticity: summarizeRuntimeGraphPlasticity("live_loop", graphWithCarryForwardSeed, builtAt, null, normalizedEventExport)
     };
 }
 export function buildCandidatePack(input) {

package/dist/src/local-session-passive-learning.js

@@ -44,6 +44,32 @@ function sanitizeToken(value) {
 function slugifyIdentity(value) {
     return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
 }
+function sortSessionRecordsDeterministically(records) {
+    return [...records].sort((left, right) => {
+        const leftTimestamp = Date.parse(left.timestamp);
+        const rightTimestamp = Date.parse(right.timestamp);
+        if (leftTimestamp !== rightTimestamp) {
+            return leftTimestamp - rightTimestamp;
+        }
+        const leftId = typeof left.id === "string" ? left.id : "";
+        const rightId = typeof right.id === "string" ? right.id : "";
+        const leftParentId = typeof left.parentId === "string" ? left.parentId : "";
+        const rightParentId = typeof right.parentId === "string" ? right.parentId : "";
+        if (rightParentId === leftId && leftParentId !== rightId) {
+            return -1;
+        }
+        if (leftParentId === rightId && rightParentId !== leftId) {
+            return 1;
+        }
+        if (leftId !== rightId) {
+            return leftId.localeCompare(rightId);
+        }
+        if (leftParentId !== rightParentId) {
+            return leftParentId.localeCompare(rightParentId);
+        }
+        return left.type.localeCompare(right.type);
+    });
+}
 function deriveChannel(sessionKey, entry) {
     const deliveryChannel = normalizeString(entry.deliveryContext?.channel);
     if (deliveryChannel !== null) {
@@ -256,7 +282,7 @@ export function buildPassiveLearningSessionExportFromOpenClawSessionStore(input)
     let droppedRuntimeNoiseCount = 0;
     let nextSequence = sequenceStart;
     let latestAssistantInteractionId = null;
-    for (const record of input.records) {
+    for (const record of sortSessionRecordsDeterministically(input.records)) {
         if (record.type !== "message") {
             continue;
         }
@@ -451,4 +477,4 @@ export function buildPassiveLearningStoreExportFromOpenClawSessionIndex(input) {
         warnings: sessions.flatMap((session) => session.warnings)
     };
 }
-//# sourceMappingURL=local-session-passive-learning.js.map
+//# sourceMappingURL=local-session-passive-learning.js.map

package/dist/src/materialization-embedder.js

@@ -0,0 +1,11 @@
+import { reindexCandidatePackBuildResultWithEmbedder } from "./local-learner.js";
+
+export async function reindexMaterializationCandidateWithEmbedder(materialization, embedder) {
+    if (materialization === null || embedder === null) {
+        return materialization;
+    }
+    return {
+        ...materialization,
+        candidate: await reindexCandidatePackBuildResultWithEmbedder(materialization.candidate, embedder)
+    };
+}

package/dist/src/openclaw-hook-truth.d.ts

@@ -2,6 +2,8 @@ import { type OpenClawBrainInstallLayout } from "./openclaw-plugin-install.js";
 export type OpenClawBrainHookInstallState = "installed" | "not_installed" | "blocked_by_allowlist" | "unverified";
 export type OpenClawBrainHookLoadability = "loadable" | "blocked" | "not_installed" | "unverified";
 export type OpenClawBrainHookLoadProof = "status_probe_ready" | "not_ready";
+export type OpenClawBrainHookGuardSeverity = "none" | "degraded" | "blocking";
+export type OpenClawBrainHookGuardActionability = "none" | "pin_openclaw_home" | "repair_install";
 export type OpenClawBrainPluginAllowlistState = "unrestricted" | "allowed" | "blocked" | "invalid" | "unverified";
 export interface OpenClawBrainHookInspection {
     scope: "exact_openclaw_home" | "activation_root_only";
@@ -24,6 +26,10 @@ export interface OpenClawBrainHookInspection {
 }
 export interface OpenClawBrainHookLoadSummary extends OpenClawBrainHookInspection {
     loadProof: OpenClawBrainHookLoadProof;
+    guardSeverity: OpenClawBrainHookGuardSeverity;
+    guardActionability: OpenClawBrainHookGuardActionability;
+    guardSummary: string;
+    guardAction: string;
 }
 export declare function inspectOpenClawBrainPluginAllowlist(openclawHome: string): {
     state: Exclude<OpenClawBrainPluginAllowlistState, "unverified">;

package/dist/src/openclaw-hook-truth.js

@@ -74,6 +74,32 @@ function describeAdditionalInstallDetail(additionalInstalls) {
         .map((install) => `${shortenPath(install.extensionDir)} (${describeOpenClawBrainInstallLayout(install.installLayout)}, ${describeOpenClawBrainInstallIdentity(install)})`)
         .join(", ")}`;
 }
+function summarizeOpenClawBrainHookGuard(inspection) {
+    if (inspection.scope === "activation_root_only") {
+        return {
+            guardSeverity: "degraded",
+            guardActionability: "pin_openclaw_home",
+            guardSummary: "current-profile hook state is not self-proven from this status scope",
+            guardAction: "Rerun status with --openclaw-home <path> to prove the current profile hook."
+        };
+    }
+    if (inspection.installState === "installed" && inspection.loadability === "loadable") {
+        return {
+            guardSeverity: "none",
+            guardActionability: "none",
+            guardSummary: "profile hook is installed and loadable",
+            guardAction: "none"
+        };
+    }
+    return {
+        guardSeverity: "blocking",
+        guardActionability: "repair_install",
+        guardSummary: inspection.installState === "not_installed"
+            ? "profile hook is missing or incomplete"
+            : "profile hook is present but OpenClaw will not load it",
+        guardAction: "Run openclawbrain install --openclaw-home <path> to repair the installed hook."
+    };
+}
 export function inspectOpenClawBrainPluginAllowlist(openclawHome) {
     const { path: openclawJsonPath, config } = readOpenClawJsonConfig(openclawHome);
     const installedPlugin = findInstalledOpenClawBrainPlugin(openclawHome);
@@ -252,6 +278,7 @@ export function inspectOpenClawBrainHookStatus(openclawHome) {
 export function summarizeOpenClawBrainHookLoad(inspection, statusProbeReady) {
     return {
         ...inspection,
+        ...summarizeOpenClawBrainHookGuard(inspection),
         loadProof: inspection.loadability === "loadable" && statusProbeReady
             ? "status_probe_ready"
             : "not_ready"