@openclawbrain/cli 0.4.13 → 0.4.14

package/dist/src/teacher-decision-match.js

@@ -0,0 +1,240 @@
+const DEFAULT_MATCH_WINDOW_MS = 60_000;
+const OPERATIONAL_DECISION_PATTERNS = [
+    /^NO_REPLY$/i,
+    /^HEARTBEAT_OK$/i,
+    /^read heartbeat\.md if it exists\b/i,
+    /^a new session was started via \/new or \/reset\./i,
+    /\[cron:[a-f0-9-]+\s/i,
+    /\[system message\]\s*\[sessionid:/i,
+];
+
+function normalizeOptionalString(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+
+function toTimestamp(value) {
+    const normalized = normalizeOptionalString(value);
+    if (normalized === undefined) {
+        return null;
+    }
+    const parsed = Date.parse(normalized);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+
+function buildSessionChannelKey(sessionId, channel) {
+    const normalizedSessionId = normalizeOptionalString(sessionId);
+    const normalizedChannel = normalizeOptionalString(channel);
+    if (normalizedSessionId === undefined || normalizedChannel === undefined) {
+        return null;
+    }
+    return `${normalizedSessionId}|${normalizedChannel}`;
+}
+
+function buildCandidateKey(sessionId, channel, createdAt) {
+    const sessionChannelKey = buildSessionChannelKey(sessionId, channel);
+    const normalizedCreatedAt = normalizeOptionalString(createdAt);
+    if (sessionChannelKey === null || normalizedCreatedAt === undefined) {
+        return null;
+    }
+    return `${sessionChannelKey}|${normalizedCreatedAt}`;
+}
+
+function buildSelectionDigestKey(selectionDigest, activePackGraphChecksum) {
+    const normalizedSelectionDigest = normalizeOptionalString(selectionDigest);
+    const normalizedGraphChecksum = normalizeOptionalString(activePackGraphChecksum);
+    if (normalizedSelectionDigest === undefined || normalizedGraphChecksum === undefined) {
+        return null;
+    }
+    return `${normalizedGraphChecksum}|${normalizedSelectionDigest}`;
+}
+
+function toRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+
+function readInteractionExactDecisionRecordId(interaction) {
+    return normalizeOptionalString(interaction?.serveDecisionRecordId)
+        ?? normalizeOptionalString(toRecord(interaction?.routeMetadata)?.serveDecisionRecordId)
+        ?? normalizeOptionalString(toRecord(interaction?.decisionProvenance)?.serveDecisionRecordId)
+        ?? normalizeOptionalString(toRecord(interaction?.metadata)?.serveDecisionRecordId)
+        ?? undefined;
+}
+
+function readInteractionSelectionDigest(interaction) {
+    return normalizeOptionalString(interaction?.selectionDigest)
+        ?? normalizeOptionalString(toRecord(interaction?.routeMetadata)?.selectionDigest)
+        ?? normalizeOptionalString(toRecord(interaction?.decisionProvenance)?.selectionDigest)
+        ?? normalizeOptionalString(toRecord(interaction?.metadata)?.selectionDigest)
+        ?? undefined;
+}
+
+function readInteractionActivePackGraphChecksum(interaction) {
+    return normalizeOptionalString(interaction?.activePackGraphChecksum)
+        ?? normalizeOptionalString(toRecord(interaction?.routeMetadata)?.activePackGraphChecksum)
+        ?? normalizeOptionalString(toRecord(interaction?.decisionProvenance)?.activePackGraphChecksum)
+        ?? normalizeOptionalString(toRecord(interaction?.metadata)?.activePackGraphChecksum)
+        ?? undefined;
+}
+
+function 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;
+}
+
+function isOperationalDecision(decision) {
+    const userMessage = normalizeOptionalString(decision.userMessage);
+    if (userMessage === undefined) {
+        return true;
+    }
+    return OPERATIONAL_DECISION_PATTERNS.some((pattern) => pattern.test(userMessage));
+}
+
+function selectNearestDecision(entries, interactionAt, maxTimeDeltaMs) {
+    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 > maxTimeDeltaMs
+            ? 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;
+}
+
+export function createServeTimeDecisionMatcher(decisions, options = {}) {
+    const maxTimeDeltaMs = Number.isInteger(options.maxTimeDeltaMs) && options.maxTimeDeltaMs >= 0
+        ? options.maxTimeDeltaMs
+        : DEFAULT_MATCH_WINDOW_MS;
+    const decisionsByRecordId = new Map();
+    const decisionsBySelectionDigest = new Map();
+    const ambiguousSelectionDigests = new Set();
+    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 decisionRecordId = normalizeOptionalString(decision.recordId);
+        if (decisionRecordId !== undefined && !decisionsByRecordId.has(decisionRecordId)) {
+            decisionsByRecordId.set(decisionRecordId, decision);
+        }
+        const selectionDigestKey = buildSelectionDigestKey(decision.selectionDigest, decision.activePackGraphChecksum);
+        if (selectionDigestKey !== null) {
+            if (decisionsBySelectionDigest.has(selectionDigestKey)) {
+                decisionsBySelectionDigest.delete(selectionDigestKey);
+                ambiguousSelectionDigests.add(selectionDigestKey);
+            }
+            else if (!ambiguousSelectionDigests.has(selectionDigestKey)) {
+                decisionsBySelectionDigest.set(selectionDigestKey, decision);
+            }
+        }
+        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);
+        if (sessionChannelKey === null) {
+            if (!isOperationalDecision(decision)) {
+                globalFallbackDecisions.push({
+                    decision,
+                    timestamps: buildDecisionTimestamps(decision),
+                });
+            }
+            continue;
+        }
+        const indexedEntry = {
+            decision,
+            timestamps: buildDecisionTimestamps(decision),
+            operational: isOperationalDecision(decision),
+        };
+        const indexed = decisionsBySessionChannel.get(sessionChannelKey) ?? [];
+        indexed.push(indexedEntry);
+        decisionsBySessionChannel.set(sessionChannelKey, indexed);
+        if (!indexedEntry.operational) {
+            globalFallbackDecisions.push(indexedEntry);
+        }
+    }
+
+    return (interaction) => {
+        const decisionRecordId = readInteractionExactDecisionRecordId(interaction);
+        if (decisionRecordId !== undefined) {
+            return decisionsByRecordId.get(decisionRecordId) ?? null;
+        }
+        const selectionDigestKey = buildSelectionDigestKey(
+            readInteractionSelectionDigest(interaction),
+            readInteractionActivePackGraphChecksum(interaction),
+        );
+        if (selectionDigestKey !== null) {
+            if (ambiguousSelectionDigests.has(selectionDigestKey)) {
+                return null;
+            }
+            return decisionsBySelectionDigest.get(selectionDigestKey) ?? null;
+        }
+        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 sessionMatch = selectNearestDecision((decisionsBySessionChannel.get(sessionChannelKey) ?? []).filter((entry) => entry.operational !== true), interactionAt, maxTimeDeltaMs);
+            if (sessionMatch !== null) {
+                return sessionMatch;
+            }
+        }
+        return selectNearestDecision(globalFallbackDecisions, interactionAt, maxTimeDeltaMs);
+    };
+}

package/dist/src/teacher-labeler.js

@@ -1,5 +1,6 @@
 import { CONTRACT_IDS, checksumJsonPayload, validateTeacherSupervisionArtifact } from "@openclawbrain/contracts";
 import { buildNormalizedEventDedupId } from "@openclawbrain/event-export";
+import { createServeTimeDecisionMatcher } from "./teacher-decision-match.js";
 const FEEDBACK_KINDS = new Set(["correction", "teaching", "approval", "suppression"]);
 const OLLAMA_ROUTE_DECISION_STREAM = "openclaw/learning-spine/serve-time-route-decisions";
 const DEFAULT_OLLAMA_BASE_URL = "http://127.0.0.1:11434";
@@ -140,41 +141,14 @@ function buildPrompt(candidates, config) {
         payload
     ].join("\n");
 }
-function buildCandidateKey(interaction) {
-    return `${interaction.sessionId}|${interaction.channel}|${interaction.createdAt}`;
-}
-function matchServeTimeDecision(interaction, exactDecisions, fallbackDecisions) {
-    const exact = exactDecisions.get(interaction.eventId);
-    if (exact !== undefined) {
-        return exact;
-    }
-    return fallbackDecisions.get(buildCandidateKey(interaction)) ?? null;
-}
 function collectCandidates(input, config) {
     const decisions = [...(input.serveTimeDecisions ?? [])].sort((left, right) => Date.parse(right.recordedAt) - Date.parse(left.recordedAt));
-    const exactDecisions = new Map();
-    const fallbackDecisions = new Map();
-    for (const decision of decisions) {
-        const userMessage = normalizeOptionalString(decision.userMessage);
-        if (userMessage === undefined) {
-            continue;
-        }
-        if (decision.turnCompileEventId !== null && !exactDecisions.has(decision.turnCompileEventId)) {
-            exactDecisions.set(decision.turnCompileEventId, decision);
-        }
-        const turnCreatedAt = normalizeOptionalString(decision.turnCreatedAt);
-        if (turnCreatedAt !== undefined && decision.sessionId !== null && decision.channel !== null) {
-            const key = `${decision.sessionId}|${decision.channel}|${turnCreatedAt}`;
-            if (!fallbackDecisions.has(key)) {
-                fallbackDecisions.set(key, decision);
-            }
-        }
-    }
+    const matchServeTimeDecision = createServeTimeDecisionMatcher(decisions);
     return input.normalizedEventExport.interactionEvents
         .filter((interaction) => interaction.kind === "memory_compiled")
         .sort((left, right) => Date.parse(right.createdAt) - Date.parse(left.createdAt))
         .map((interaction) => {
-        const decision = matchServeTimeDecision(interaction, exactDecisions, fallbackDecisions);
+        const decision = matchServeTimeDecision(interaction);
         const userMessage = normalizeOptionalString(decision?.userMessage);
         if (decision === null || userMessage === undefined) {
             return null;
@@ -421,4 +395,4 @@ export function createTeacherLabeler(config) {
     }
     return createOllamaTeacherLabeler(config);
 }
-//# sourceMappingURL=teacher-labeler.js.map
+//# sourceMappingURL=teacher-labeler.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclawbrain/cli",
-  "version": "0.4.13",
+  "version": "0.4.14",
   "description": "OpenClawBrain operator CLI package with install/status helpers, daemon controls, and import/export tooling.",
   "type": "module",
   "main": "./dist/src/index.js",
@@ -48,9 +48,11 @@
     "@openclawbrain/compiler": "0.3.5",
     "@openclawbrain/contracts": "^0.3.5",
     "@openclawbrain/events": "^0.3.4",
+    "@openclawbrain/event-export": "^0.3.4",
     "@openclawbrain/learner": "^0.3.4",
     "@openclawbrain/pack-format": "^0.3.4",
-    "@openclawbrain/event-export": "^0.3.4"
+    "@openclawbrain/provenance": "^0.3.4",
+    "@openclawbrain/workspace-metadata": "^0.3.4"
   },
   "bin": {
     "openclawbrain": "dist/src/cli.js",
@@ -62,4 +64,3 @@
     "test": "node --test dist/test/*.test.js"
   }
 }
-